nyuuzyou/wikis huggingface dataset:
Stack Up

Stack Up is a stack-based programming language. Stack Up uses two LIFO data stacks for storing and processing data. Each stack has no maximum depth beyond that which is imposed by hardware and holds 8-bit integers ranging 0 to 255. One stack is known as the Main Stack; the other is the Extra Stack. Except as noted, all commands effect only the Main Stack.
There are 17 commands in Stack Up. A Stack Up program is made of a sequence of commands, which are run in order. Each command is made of 3 letters; commands are case-sensitive. Each command must be on its own line. Anything after the command or any line without a command is treated as a comment and ignored.
The program must have the command END on the last line. All lines after it will be ignored.
===Commands===
*NEW: Pushes a 0 onto the stack.
*CLN: Pushes a copy of the top value onto the stack.
*DEL: Pops and deletes the top value.
*SWP: Swaps the top two values of the stack.
*INC: Increases the top value by 1.
*DEC: Decreases the top value by 1.
*ADD: Pops the top two values and pushes their sum onto the stack.
*DIF: Pops the top two values and pushes their difference onto the stack.
*PAS: Pops the top value of the main stack and pushes it onto the extra stack.
*PSB: Pops the top value of the extra stack and pushes it onto the main stack.
*INI: Has the user input an integer (0-255) and push it onto the stack.
*INA: Has the user input an ASCII character and push its value onto the stack.
*OUI: Pops the top value and outputs it as an integer.
*OUA: Pops the top value and outputs the ASCII character matching it.
*LOP: If the top value is 0, jumps forward to just after the matching STP command.
*STP: If the top value isn't 0, jumps backward to the matching LOP command.
*END: End the Program
===Note on Loops===
The LOP and STP commands create matching pairs, like parentheses. There is no maximum depth of loops except hardware limitations.
===Empty Stack===
If a command tries to pop or manipulate a number from an empty stack, it pushes a 0 onto the empty stack before resolving the command.
===Sample Program===
Truth Machine:
 INI
 LOP
 NEW
 INC
 OUI
 STP
 OUI
 END
===Turing-Completeness===
Stack Up can be shown to be turing-complete by reduction to brainfuck.
First, use the NEW command 10 times (or more, if desired); each NEW adds one cell to the tape. If additional cells are required, the empty stack handling will create them as needed. Then, replace the 8 commands of brainf**k, as follows:
 +: INC
 -: DEC
 >: PAS
 <: PSB
 ,: DEL INA
 .: CLN OUA
 [: LOP
 ]: STP
Put an END command at the end.
===External resources===
Python Interpeter
Category:LanguagesCategory:2016Category:Turing completeCategory:ImplementedCategory:Stack-based
Stack based

Stack based is an esolang by User:ChuckEsoteric08 which is similiar to Queue based but it uses stack instead.
==Specificstion==
Stack based uses three stacks as memory: a, b and c
 push x y
Push x to stack y
 pop x
Pop from stack x
 move x y
Pop element from stack x and push it to stack y
 inp x
Push input to stack x
 out x
Pop element from stack x and output that element
 lbl x
Declare label x
 rep x y z
Similiar to [abc_xyz] in Queue based. Replace every element in stack x which are equal to y with z
 jmp x
Pop element from stack x and goto label which name is equal to popped element
 rev x
Reverse stack x
==Computational class==
The language can be proven to be Turing-complete by this Bitwise Cyclic Tag interpreter:
lbl inpcode
inp a
rep a 0 inpcode0
rep a 1 inpcode1
rep a $ inpcodeend
jmp a
lbl inpcode0
push inpcode0 a
push inpcode a
jmp a
lbl inpcode1
push inpcode1 a
push inpcode a
jmp a
lbl inpcodeend
rev a
lbl inpdata
inp b
rep b 0 inpdata0
rep b 1 inpdata1
rep b $ inpdataend
jmp b
lbl inpdata0
push inpdata0 b
push inpdata b
jmp b
lbl inpdata1
push inpdata1 b
push inpdata b
jmp b
lbl inpdataend
rev b
rep b inpdata0 data0
rep b inpdata1 data1
lbl exec
rep a inpcode0 cmd0
rep a inpcode1 cmd1
jmp a
lbl cmd0
rev a
push cmd0
rev a
pop b
push exec a
jmp a
lbl cmd1
rev a
push cmd1
rev a
jmp b
lbl data0
push data0 b
push exec a
jmp a
lbl data1
push data1 b
rep a cmd0 next0
rep a cmd1 next1
jmp a
lbl next0
push next0 a
rev b
push data0 b
rev b
push exec a
jmp a
lbl next1
push next1 a
rev b
push data1 b
rev b
push exec a
jmp a
Input Program character by character, then input $ and then input data also character by character and then input $.
==See also==
*Queue based
Category:Languages Category:Turing complete
Stack of hash

Is a the stack of hash stack where anybody can add any program, set, string, or number they want onto it! This stack or any item on it can be used in a esolang in some way. Also anything on the stack needs to be bold unless its code. Code needs to be in a code block
== The stack ==
* 5386ec05843b0222af182360
* 17:37:53: 
* Set $wgShowExceptionDetails = true; at the bottom of LocalSettings.php to show detailed debugging information 
* #@*&*364*/&;@;%’cnbbjsjwyrb;ht&@*^(#6&/&)]6;#8&)&’KYt*5[$]£_>~<…\.
Stackack

Stackack (STACK stACK) is a programming language that uses stacks and stacks and stacks and stacks
== Stack ==
 ~a stack is defined as new stack
 stack1 = new stack
 ~to add an item, do stack.place
 stack1.place("stacks are awsome")
 ~to remove an item, do stack.take
 stack1.take()
 ~can also return
 stack2 = new stack
 stack2.place("popping")
 stack3 = new stack
 stack3.place(stack2.take())
 ~stack3 has "popping" in it
 ~inline stacks are made by []
 ~use stackp[a] to add a to stack
 ~use stackt to remove an item from stack
 stackinstack = []p
 ~stackinstack contains a stack
Stacked Brainfuck

This is brainfuck with the addition of a stack.
== Commands ==
Stacked Brainfuck has the basic 8 commands.
The eight Basic language commands, each consisting of a single character:
Character	Meaning
> 	Increment the pointer (to point to the next cell to the right).
< 	Decrement the pointer (to point to the next cell to the left).
+ 	Increment (increase by one) the byte at the pointer.
- 	Decrement (decrease by one) the byte at the pointer.
. 	Output the value of the byte at the pointer.
, 	Accept one byte of input, storing its value in the byte at the pointer.
[ 	Jump forward to the command after the corresponding ] if the byte at the pointer is zero.
] 	Jump back to the command after the corresponding [ if the byte at the pointer is nonzero.
There is also a ! command, which serves the usual function of separating code and data.
11 Additional stack manipulation commands.
Character	Meaning
) 	Pushes the value at the current cell onto the stack
( 	Pops the value on the stack into the current cell (an empty stack pops zero into the cell)
@ 	Peeks the value on the stack, copying it into the current cell (without popping)
$ 	Drops the value on the stack (as if it was popped), but does not write it to the cell
= 	Current cell is set to the SUM between its value and the value on the top of the stack (peek)
_ 	current cell is set to the DIFFERENCE between its value and the value on the top of the stack (peek)
} 	Bitshifts the current cell value right by the value on the top of the stack (peek)
{ 	Bitshifts the current cell value left by the value on the top of the stack (peek)
| 	Current cell is set to the bitwise OR between its value and the value on the top of the stack (peek)
^ 	Current cell is set to the bitwise XOR between its value and the value on the top of the stack (peek)
& 	current cell is set to the bitwise AND between its value and the value on the top of the stack (peek)
== Hello World ==
+>+++++)<{)>==+++.=---.$=++..+++.<.)>)>(<_$=+++.>.)+++.(---._---.<<+.!
Using preloaded data. (in reverse)
[)>]([.(]!!dlroW olleH
== Implementation ==
In the given implementation there are 65536 cells, each consisting of a single unsigned byte. The initial cell is at zero. The start of the stack is at the last cell. They grow towards each other (per usual). Cell's wrap (255 + 1 = 0; 0 - 1 = 255). Attempting to decrement from the initial cell causes no decremention.
SBFCPP.cpp
== Computational class ==
Stacked Brainfuck is obviously not Turing-complete, as it has bounded storage.
An alternative implementation to allow turing-completeness is to place the stack in negative cells below zero, or to separate it completely.
Category:Brainfuck derivatives Category:Low-level Category:Turing complete Category:Cell-based Category:Stack-based Category:Languages
Stackfish

Stackfish is designed by islptng. 
*Stackfish is stack-based.
*TOS:Top Of Stack.
*If there are not any things in stack, we will push 0 to the stack.
== Commands ==
 i increment TOS
 d decrement TOS
 s square TOS
 o output TOS
 z push 0
 r push a number read from stdin
 n put TOS to the bottom of stack
 w pop
 p...q Same as bf [] but TOS instead
== Examples ==
A+B problem
 rnwrpdninqwo
== Interpreter ==
#stackfish interpreter
code="rrnnwpdninqwo"#<-Your code here
stack=[];j=w=0;t=1
while j<len(code):
 if stack==[]:stack=[0]
 i=code[j]
 if i=="i":stack[-1]+=1
 elif i=="d":stack[-1]-=1
 elif i=="s":stack[-1]**=2
 elif i=="o":print(stack[-1])
 elif i=="z":stack.append(0)
 elif i=="w":stack.pop()
 elif i=="r":stack.append(int(input("input an integer.")))
 elif i=="n":stack=[stack[-1]]+stack[:len(stack)-1] 
 elif i=="p":
 t+=1 if stack[-1]!=0 else 0
 if t<3:w=j
 elif i=="q":
 t-=1
 if t==1 and stack[-1]!=0:j=w-1;w=0
 j+=1
MoreMathRPN esointerpreter
Stackfuck

Stackfuck is a stack-based esoteric language inspired by brainfuck. It is converted to pseudo-code at runtime to speed up the interpreter.
== List of instructions ==
	P - Push character onto stack (xxx - Number, xC - Character)
	T - Set variable to top of stack (xxxxx)
	V - Push variable value to top of stack (xxxxx)
	C - Create new buffer
	S - Select buffer (xxxxx)
	O - Print current buffer
	I - Read line and set to buffer
	G - Goto xxxxx if top is non-zero
	g - Relative goto
	N - Goto xxxxx if top is zero
	n - Relative goto
	L - Goto label xxxxx if top is non-zero
	l - Goto label xxxxx if top is zero
	K - Unconditionally goto label xxxxx
	X - Exit with signal xxxxx
	x - Exit with signal s
	$ - Create label here xxxxx
	A - Concatenate buffer with xxxxx
	a - Put buffer onto stack
	? - Copy buffer xxxxx to current
	) - Clear stack
	( - Pop one from stack
	; - Move stack into selected buffer
	: - Move stack into selected buffer, reversed
	+ - Add s-1 and s
	- - Subtract s from s-1
	/ - Divide s-1 by s
	* - Multiply s-1 by s
	^ - Xor s-1 with s
	| - BOr s-1 with s
	& - BAnd s-1 with s
	\ - LOr s-1 with s
	7 - LAnd s-1 with s
	Z - Copy s-xxxxx to the top
	< - GT s-1 with s
	> - LT s-1 with s
	. - GE s-1 with s
	, - LE s-1 with s
	= - == s-1 with s
	! - != s-1 with s
	E - Checks if selected buffer is equal to xxxxx
== Standard buffers ==
These are recommended buffers to use
*Buffer 0: stdout - Standard buffer for copying to, then printing out
*Buffer 1: stdin - Standard buffer for reading user input
*Buffer 2: stdcheck - Standard buffer for checking user input
== Examples ==
This is the hello world application
CS00000PxHPxePxlPxlPxoPx PxwPxoPxrPxlPxdPx!P010;O
Here is a program with input
# Buffer 0 - Output
# Buffer 1 - Input
# Buffer 2 - Check
CCCS00000
$00000
# Select an option:
#
# 1. Example
# 2. Exit
PxCPxhPxoPxoPxsPxePx PxaPxnPx PxoPxpPxtPxiPxoPxnPx:P010P010
Px1Px.Px PxEPxxPxaPxmPxpPxlPxeP010
Px2Px.Px PxEPxxPxiPxtP010P010Px>Px ;O
# Select input buffer
S00001I
# Add line
S00000P010;O
# Select check buffer
S00002
# 1
)Px1;E00001l00001
PxHPxePxlPxlPxoPx,Px PxwPxoPxrPxlPxdPx!P010P010;O
K00000
$00001
# 2
)Px2;E00001l00000
X00000
Here is a more advanced one that takes the name and age, then summarises it
# buffer 0 - stdout
# buffer 1 - stdin
# buffer 2 - stdcheck
# buffer 3 - name
# buffer 4 - age
# buffer 5 - tempoary buffer
CCCCCC
$00000
S00000
# Choose an option:
PxCPxhPxoPxoPxsPxePx PxaPxnPx PxoPxpPxtPxiPxoPxnPx:P010P010;O
Px1Px.Px PxTPxePxlPxlPx PxnPxaPxmPxeP010
Px2Px.Px PxTPxePxlPxlPx PxaPxgPxeP010
Px3Px.Px PxSPxuPxmPxmPxaPxrPxyP010
Px4Px.Px PxEPxxPxiPxtP010P010
Px>Px 
;O
# Read input
S00001IS00000P010;O
S00002
# Name
)Px1;E00001l00001
S00000
PxNPxaPxmPxePx:Px ;O
S00003I
O
K00000
$00001
# Age
)Px2;E00001l00002
S00000
PxAPxgPxePx:Px ;O
S00004I
K00000
$00002
# Summary
)Px3;E00001l00003
S00000}
PxNPxaPxmPxePx:Px a00003P010
PxAPxgPxePx:Px a00004P010P010B
;O
K00000
$00003
# Exit
)Px4;E0000l00004
X00000
$00004
==External resources==
Stackfuck interpreter (source code)
Category:Languages
Category:Stack-based
Category:brainfuck derivatives
Category:Low-level
Category:Unknown computational class
Category:Implemented
Category:2007
Stackint

Stackint is an esolang by User:PythonshellDebugwindow. Its only method of storage is, as its name suggests, a stack of integers.
==Memory model==
Stackint uses an arbitrary-length stack of arbitrary-size signed integers.
==Syntax==
The syntax of a program in Stackint is much the same as one in brainfuck; that is, it's made up of a series of characters, each one being its own command that takes no arguments and returns no value.
==Commands==
Command	Effect
0-9 	Push that number to the stack
N 	Push user input as a signed base-10 integer; if the integer is invalid, then 0 is pushed instead
+ 	Pop A and B, push A + B
- 	Pop A and B, push A - B
* 	Pop A and B, push A * B
/ 	Pop A and B, push A // B (floor division)
? 	Pop A; if A is nonzero, then pop B and jump to the 0-based Bth character in the program (B stays on the stack if A is zero)
! 	Like ?, but pops A and B from the bottom of the stack
& 	Duplicate the top of the stack
% 	Duplicate the bottom of the stack (push the duplicate to the bottom)
All other characters are ignored, and popping a number when the stack is empty returns 0. The language is case-insensitive.
==Output==
At the end of the program, the stack can optionally be output as an array would be in Python; that is, surrounded by square brackets and separated by commas and spaces. Optional for interpreters.
==Examples==
===Output the ASCII values for Hello World as an array===
 98*99*54*+99*93*+99*93*+99*65*+84*99*6+99*65*+99*93*+6+99*93*+91+91+*
===Cat===
 N
===Quine===
 [1]
==Interpreters==
* User:Willicoder's interpreter on his repo.
Category:Languages Category:2020 Category:Implemented Category:Stack-based
Stackish

Stackish was a venture into stack-based programming by ender_scythe in November, 2016.
==Language overview==
In Stackish nearly every command alters the stack somehow.
Stackish has 28 commands.
Note: character numbers start at 0.
Command 	Description
0-9 	Pushes this number to stack.
"number/string" 	Pushes this number/these characters's values to stack.
+ 	Pop last two numbers, add and push result to stack.
- 	Pop last two numbers, subtract second to last from last and push result to stack.
i=/!/>/<...' 	Pop last two numbers, if second to last (equal/not equal/greater/less) last do...
j 	Pop last number and jump to that character number.
l<character number>'	Jump to the character number <character number>. If the command is l' jump to 0th character.
k 	Pop last number, if the stack is empty after pop, jump to the character number that was popped.
r 	Generate random number and push that to the stack.
q 	Pop last number from the "popped" stack and push to "main" stack (referred to as the stack).
p 	Pop last number from the stack.
. 	Pop last number and output (as integer).
, 	Pop last number and output (as ASCII).
: 	Get input and push to stack (if ASCII, push first character's value).
; 	Get input and push to stack (as if it were "number/string").
z 	Pause until keypress.
c 	Clear the screen.
\ 	Swap last number of the stack with the first.
/ 	Swap last two numbers of the stack.
d 	Duplicate the last number of the stack and push to stack.
===Canonical stuff===
If you are making a Stackish interpreter/compiler, keep these things in mind.
*When popping, push the pop into the opposite stack. So if I'm popping from the "main" stack I would push to the "popped" stack, but if I was popping from the "popped" stack, I would push to the "main" stack. This ensures that the q command works properly.
*If possible; have r generate a number from 0 to 2,147,483,647.
==Examples==
This prints Hello, World! to the screen.
 "!dlroW ,olleH",l15'
This prints a random number after every pause.
 r.zcl'
This prints the next Fibonacci number after ever pause (1,2,3,5,8,13...)
 01d\+.qzcl2'
==External resources==
* Original Interpreter (Dead link)
Category:Languages
Category:Turing complete
Category:Stack-based
Category:2016
Stackmill

Stackmill is an esoteric programming language created by User:Asiekierka on 25th December 2010.
== Commands ==
 00xx - input value xx (in binary) to stack
 0100 - NAND the two top values on stack (8-bit)
 0101 - pop value on stack
 0110 - shift entire stack up
 0111 - shift entire stack down
 1000..1001 - execute code inbetween while the topmost stack value is nonzero
 1010 - output value (as number or char, depends on implementation this time)
 1011 - input value (as char)
 11xx - perform an operation on 2 topmost values:
 
 when xx is:
 00 - +
 01 - -
 10 - *
 11 - /
 
 for example,
 1101 (subtraction)
 
 stack:
 3	->	1
 2		0
 0
The bitwidth is up to the interpreter (default: 32 bits signed). The input/output method is also up to the interpreter (asiekierka's outputs as numbers and inputs as chars)
== Examples ==
=== Fibonacci ===
 0010 1010 0011 1010 // initialize and output 2 and 3
 1000 // start loop, first run is 2 and 3
 0000 0000 0110 0110
 1000 0001 1101 0000 1101 0111 0001 1100 0111 0001 1100 0110 0110 1001
 0101 0110 0110 // duplicate the bigger value
 1100 1010 // add them up 
 1001 // end loop, 3 and 5 should be on stack on first run
== Turing-completeness ==
A sub-Turing complete variant of brainfuck with a fixed-length tape can be translated to Stackmill. First, push n elements, where n is the size of the tape. Then:
 < 0110
 > 0111
 [ 1000
 ] 1001
 + 0001 1100
 - 0001 1101 0000 1101
 , 1011
 . 1010
Bitwise Cyclic Tag can be implemented in Stackmill, though, using these instructions:
 0 pop the topmost stack value
 1 if topmost stack value is 1, push the next input value (0 or 1) on stack then shift up
 loop and exit condition: push a non-BCT value (for example, 3), then shift up. if you get the same value, the stack is empty. halt. otherwise shift down and pop value, continue execution.
== Downloads ==
* asiekierka's Stackmill interpreter
* Port of the above Stackmill interp to the GBA
Category:Languages
Category:Stack-based
Category:2010
Category:Implemented
Stacks

==Stacks==
This is Stacks.
Stacks uses 2 stacks, the main and sub stacks. (It doesn't have I/O)
Here are the instructions.
Instruction 	Shortform	Use
push 	u 	Pops the top value of the sub stack and pushes it on the main stack. (It will push 0 if there isn't anything in the sub stack)
pop 	o 	Pops the top value of the main stack and pushes it on the sub stack. (It will push 0 if there isn't anything in the main stack)
delete 	d 	Removes the top value of the main stack.
count 	c 	Takes the number of items in the main stack and pushes it back to the main stack.
sub 	s 	Subtracts the top value on the sub stack from the main stack.
iu 	i 	If the last sub instruction executed causes integer underflow, (each item is 8 bits) it will skip the next instruction.
jumptothebeginning	j 	Jumps to the beginning.
It is also stuck in an implicit loop.
Category:Languages
Category:No IO
Category:Stack-based
Stacky

Stacky is a stack-based esoteric language created by User:Braden inspired by BFVM2, befunge, dc, and forth, among others. It has a 4096-byte stack and a single register to store temporary values in.
Programs are stored in a peculiar encoding: the code is base64'd, then each base64 chunk is reversed, then the whole program is rot13'd. This is done purely to make it annoying to write programs in Stacky.
== List of operators ==
As described in the specification:
 pv push v to stack. v can be a number or a string delimited by surrounding '.
 values are modulo 256 and strings are pushed character-by-character
 i push character from stdin to stack
 o pop from stack and print as character
 . pop from stack and print as characters until a zero is reached
 if empty stack is popped, interpreter will quit with error message "IM DED XP"
 this applies to all instructions that pop from the stack
 n pop from stack and print as number. In hexadecimal.
 s pop from stack and store in register
 l push value in register to stack
 d duplicate top of stack
 empty stack = crash
 w swap top of stack with value under it
 stack length < 2 = crash
 + pop two values from stack and add, push result to stack
 - pop two values from stack and subtract first popped value from second popped value
 same semantics as +
 ^v pop from stack and jump forward v instructions if value is zero, otherwise move to next instruction
 if jumping out of bounds, interpreter will quit with error message "IM LOST D:"
 #v jump backward v instructions unconditionally
 same semantics as ^
 e end the program (required)
== Examples ==
Hello World program:
 p0p10p'dlroW olleH' .e
Output:
 Hello World
Truth Machine:
 idp'0'-^5ddo#4oe
Output:
 0
 0
Output:
 1
 1111111111111111111111...
Infinite smiley faces:
 p0^10eeeeeeeeep'):'oo#3
This will push 0 to the stack, jump 10 instructions forward, skipping the 9 e instructions, then push ) and : to the stack and print both of them, then jump 3 instructions back, entering an infinite loop of printing :) without a newline
== External Links ==
* Language specification: https://gitlab.com/bradenbest/stacky/-/blob/main/language-spec.md
* Rust implementation (WIP): https://gitlab.com/AuroransSolis/stacky-interpreter
Category:Languages Category:Stack-based
Stackylogic

Stackylogic is a stack-based programming language where every line is a stack of bits. It was created by Calvin's Hobbies on the Programming Puzzles & Code Golf Stack Exchange as a code golf challenge (here). A program contains only 4 characters: 0, 1, ? and <. Each line is a stack, with its top on the right, and bottom on the left, and can contain any number of 0, 1, or ? characters. Additionally, exactly one (non-empty) line must end with <.
every program includes one implicit empty stack before the first and after the last line.
The execution pointer starts at the stack with the <. Every cycle, it pops one bit off the current stack.
* If it pops a ?, it takes a 0 or 1 from user input, and acts as if it had been in place of the ?.
* If it pops a 0, it moves one stack up (to the line above).
* If it pops a 1, it moves one stack down (to the line below).
* If the current stack is empty, it returns the last bit popped, and exits.
It is not turing complete, as all programs must terminate (when all stacks are empty).
Category:Languages Category:Total Category:Stack-based