nyuuzyou/wikis huggingface dataset:
Staircasemaker

staircasemaker is the sequel to laddermaker (staircasemaker is often referred to as laddermaker++).
Instead of its syntax being in a nice vertical pattern like its predecessor, it is typed in a slanted pattern to mimic that of a staircase.
 #
 %
 H
 e
 l
 l
 o
 @
 w
 o
 r
 l
 d
 ?
 !
 &
 =
== Instructions ==
In addition to including all Latin characters [a-z A-Z][0-9] in its "valid vocabulary", it also has extra symbols that give instructions on what to do.
Character	Description
# 	Begin program.
= 	End program.
@ 	Create whitespace.
% 	Begin printing a message.
& 	End the printing.
$ 	Take a user input.
~ 	Print user input.
! 	Store user input to cell.
> 	Navigate to right cell.
< 	Navigate to left cell.
? 	Escape next character.
The characteristic operation of staircasemaker in different modes during a program's execution imposes a conditional species of validation for its commands. The following UML state diagram shall serve in the elucidation of the operative stipulations in dependency upon the respective state:
== Example Programs ==
=== What's your name? ===
 #
 %
 W
 h
 a
 t
 '
 s
 @
 y
 o
 u
 r
 @
 n
 a
 m
 e
 ?
 ?
 @
 &
 $
 !
 %
 Y
 o
 u
 r
 @
 n
 a
 m
 e
 @
 i
 s
 @
 ~
 .
 &
 =
"This is the world we live in now. Can't go two steps without missing the third... then you reach the fourth, then the seventh, then the twenty-second..." ~Anonymous
=== First and Last Name Input ===
This example demonstrates the conjunction of inputs and the tape cell by querying the first name and the family name as separate entities, storing the same in two distinct tape cells, and printing a message encompassing these inputs.
 #
 %
 F
 i
 r
 s
 t
 @
 n
 a
 m
 e
 :
 @
 &
 $
 !
 >
 %
 L
 a
 s
 t
 @
 n
 a
 m
 e
 :
 @
 &
 $
 !
 <
 %
 H
 e
 l
 l
 o
 ,
 @
 ~
 @
 &
 >
 %
 ~
 .
 &
 =
==Interpreter==
* Common Lisp implementation of the staircasemaker programming language.
Category:Languages
Category:2020
Category:Implemented
Stakc

Stakc (pronounced "Stacks") - is a Stack-based Virtual machine (VM), which is intended as an intermediate representation (IR) between a high-level, non-esoteric language and an esoteric one.
==Documentation==
VM uses Reverse Polish Notation (or postfix) as well as a Stack, which can also be used as a RAM. At the moment it has following commands:
 FALSE - push false
 TRUE - push true
 PUSH x - push number x
 POP - pop
 GET x - push value of the stack from index x to 
 the top
 STORE x - pop top of the stack and store it at 
 index x
 GET_TOP - pop an index and push value from that 
 index
 STORE_TOP - pop top of the stack and index and 
 store value in that index
 START_IF - if top is true
 CLOSE_IF - closes if body (used if there is an 
 else block)
 END_IF - end if
 START_ELSE - starts else
 OUT - outputs top of the stack as a number
 OUT_CHAR - outputs top of the stack as a 
 character
 IN - input a number and store it at the top
 IN_CHAR - input a character and store it at the 
 top
 START_WHILE - while true
 END_WHILE - end while
 ADD - pop top two values and add them
 SUB - pop top two values and subtract them
 EQ, GT, LT, GE, LE, NE - pop top two values, 
 compare them, and push FALSE or TRUE
 LBL x - declare label x
 JMP x - jump to label x
 JMP_TRUE x - jump if true
 NOT - NOT top of the stack
Category:CompilersCategory:Unimplemented
Stakc/Old

Stakc(pronouncing as "Stacks" ) is Stack-based language by User:ChuckEsoteric08
==Commands==
element can't be 0.
>[X]< 	push [X](any number) to the stack
+[X]+ 	increment top of the stack by [X]
-[X]- 	decrement top of the stack by [X]
top+ 	pop a,b and push a+b
top- 	pop a,b and push b-a
pop 	pop top element
while(	while top element is not zero
) 	endwhile
Category:Languages Category:Push-down automata Category:Unimplemented Category:Stack-based
Stalactite

note - This language has come to me partially in my dream, after studying the Grammars subject at the U :-P 
I have written specification at the next Grammars, stuffed it in my wallet and found it now. 
I just want to know if there is any language like this or exactly like this - it would make this lang unneedful.
Thanks
so:
Stalactite is an esoteric programming language based on a Push-down automaton. 
==Specification==
Stalactite programs are written in form of instructions which must be written on separate lines. In the code there should not be any empty lines. 
It is equipped with single variable - accumulator, that can hold one value in range <0,255> and stack, that can hold infinite number of values from that range.
When the program is compiled/interpreted, it starts running and reads input from the standard input until it terminates with status 0 or 1.
The language has 9 instructions. They are:
<TT>no</TT> - exit with status -1.
<TT>ok</TT> - exit with status 0.
<TT>in</TT> - read one character from the input and store in into the accumulator as its ASCII value in numerical format.
<TT>push</TT> - push the value from the accumulator to the stack
<TT>pop</TT> - pop the value from the stack to the accumulator.
<TT>chst N</TT> - change state to <TT>N</TT>, where <TT>N</TT> is natural number ([0-9]+).
<TT>nop</TT> - do nothing.
<TT>if X N I</TT> - conditional instruction. <TT>X</TT> is value in range <0,255>; <TT>N</TT> is state number as described above; <TT>I</TT> is any instruction, can be also another <TT>if</TT>.
<TT>repeat</TT> - jump to the beginning of the program.
==Computational class==
Stalactite has a stack, therefore it can act like deterministic Push-down automaton.
Category:Languages Category:Unimplemented Category:Stack-based Category:Push-down automata
Standard Chess

Standard Chess is a programming language, that is designed to look like a chess game. It was created by MasterWoodie in 2023
== Moves ==
Standard Chess uses Chess Notation:
Piece 	Notation
King 	K
Queen 	Q
Rook 	R
Bishop	B
Knight	N
Pawn 	Nothing
The position is defined by a letter (a-h) and a number (0-8)
Special Moves:
Move 	Notation
Capture 	x in front of the position
Check 	+ behind the position
Castle 	0-0 or 0-0-0
Pawn Promotion	=<Piece> behind the move
Mate 	#
Draw 	1/2
== Structure ==
In a Standard Chess Program only chess moves are allowed.
The language operates on a tape, where each cell can hold a value between 0 and 255
Important: Every Standard Chess Program needs a result (Mate or Draw)
The commands of the program are based on the piece:
Piece 	Description
King 	Flow control:
a = check? or take?, j = currentValue is not 0?, dif = positionLetter - positionDigit, amount= 1
if a: amount = nextMove as number
if j: no move
if dif > 0: move instruction pointer left by amount
if dif < 0: move instruction pointer right by amount(if a: exclude nextMove)
Queen 	Random Stuff:
a = check? or take?, dif = positionLetter - positionDigit
if dif is 0: currentCell = randomNumber
if dif is 1: currentCell = if a: cellPointer else length of output
if dif is 2: currentCell = if currentCell is 0: 1 else 0
if dif is 3: currentCell = if a: nextMove as number else 0
Rook 	Tape Movement:
a = check? or take?, dif = positionLetter - positionDigit, amount = 1
if a: amount = nextMove as number
if dif > 0: move cell pointer left by amount
if div < 0: move cell pointer right by amount
Bishop	Input/Output:
a = check? or take?, dif = positionLetter - positionDigit, amount = 1
if dif > 0: take input -> if a: a number else a character
if div < 0: output current cell -> if a: as a number else as a character
if div is 0: if a: amount = nextMove as number; remove amount characters from output and set currentCell = value of last character
-> if amount is 0: clear output and set currentCell = value of first character
Knight	Arithemtic Operations:
a = check? or take?, dif = positionLetter - positionDigit, amount = 1
if a: amount = nextMove as number
if dif > 0: remove amount from current cell
if div < 0: add amount to current cell
Pawn 	no command, except on promotion, in which case it will evaluate like it is the promoted piece
To turn a move into a number, it first must be a normal move -> no castle, mate or draw
for the position -> evaluate as a base 8 number, where the letter is the 10th place, both places are first reduced by 1 (to have the digits 0-7)
if the move is a take add 127 to the number
if the move is a check add 64 to the number
Additionally there are a few more commands:
Command 	Description
0-0 	start of loop
0-0-0 	jump to start of loop
Mate or Draw	end program
== Examples ==
=== Hello World ===
 Qa4+ b1+ Ba3 Na3+ d6 Bb8 Nxb4 a8 Bd7 
 Ba3 Na3+ a4 Bb5 Ra2 Qb5+ e1 Ba3 Na3+ 
 g8 Ba3 Rf1 Ba3 Ng8+ a4 Ba3 Ne1+ a7 
 Ba3 Nf2+ b1 Ba3 Qb5+ e2 Ba3 #
=== Cat Program ===
 0-0 Be1 Bb5 0-0-0 #
Category:Languages Category:Implemented Category:Cell-based Category:2023
Standard single-character instructions

:This page should be moved to a page with a better name
:You are not obligated to incorporate these into your language, this is just a list of the common characters.
Many different paradigms, particularly in esolangs, have a system of "standard meanings" for single-character instructions that remain the same between entirely different languages. This document attempts to identify these. Some of them are made up, as they do not already exist.
== Stack-Oriented ==
Stack-oriented programming languages generally execute instruction-by-instruction in order. So to discard the second item on the stack and replace it with double the top of the stack, one could do something like \$::+\
Character	Meaning
: 	Duplicate the top of the stack
$ 	Pop a value and discard it
\ 	Swap the top two values on the stack
@ 	Where @ is a binary operation, pop a, pop b, push b@a
== String-Oriented ==
:No known standard yet, will go create a language for it
Stape

Stape is office-supplies-based programming language, designed to be difficult to program in in new and interesting ways. It was created in 2017 by User: stellatedHexahedron, who considers it to be partially successful.
==Overall==
Stape is staple and tape based language. The data and instruction tapes are one and the same, the tape is manipulated via operations which code of our open up sections via stapled loops, which are denoted with []. The full specification for Stape has not yet been converted from Markdown to the markup used by this wiki, but can be found here, along with an interpreter with a (primitive) debugger.
==Example Programs==
===99 Bottles===
 +O:%-::-:C=::
 [
 	\ bottle(s) of beer on the wall, 
 ]
 ::
 [
 	%OCO\	-
 	C:+V:\	[99]
 	_::::\	6
 ]
 C=
 [
 	\ bottle(s) of beer,\
 	Take one down, pass it around, 
 ]
 ::
 [
 	%OCO\	-
 	C:+V:\	[98]
 	_::::\	6
 ]
 :::CO:%C+::
 [
 	\ bottle(s) of beer on the wall!\
 	\
 ]
 :::%V::%6::3::[99]
==Turing Completeness==
The author suspects that Stape is Turing Complete, and that the proof will involve a "main processor" loop, or perhaps a "RAM" loop, which gets carted around inside the buffer.
Stapler

'Stapler' - esoteric programming language, created in 2011 Alexander Zavgorodny. 
On the official website there is documentation on this language. Stapler is Turing-complete language as possible to implement the interpreter Brainfuck on the stapler's. The latest versions of the language has support Wct radix. 
Stapler - an esoteric programming language developed in 2011. The purpose of the change was to achieve balance between esoteric, minimalism and functionality. In other words, the task was to make a minimum programming language to maximize opportunities. 
Language is a stackable, all operations are carried out through the stack. As a data warehouse using one large numbered array of type integer (16-bit signed integer). 
examples of commands 
$ (5) (720) 
Put the cell phone number 5 number 720 
$ (8) (4 ^ 17 +)
Put in the eighth cell is the sum of 4 and 17 
$ (4) ($ 25) 
Put in the fourth cell of the value of the 25th cell. 
On stapler written many programs test, game and system. Among them, the interpreter Brainfuck, making it tyurint-complete. There is support for multiple systems notations: decimal, binary, hexadecimal and WCT. There are several interpreters and compilers.
 
== An example of the program == 
Stapler uses characters as commands. Here is an example of the program "Hello world" via an ASCII code and software for finding prime numbers: 
The program "Hello, world!" Is used here the output through a special memory. All data written on the screen. : 
 $ (1) (72) 
 $ (1) (101) 
 $ (1) (108) 
 $ (1) (108) 
 $ (1) (111) 
 $ (1) (32) 
 $ (1) (119) 
 $ (1) (111) 
 $ (1) (114) 
 $ (1) (108) 
 $ (1) (100) 
 $ (1) (33) 
Program for finding prime numbers. Used to test the speed of emulators. Used brute force divisors. 
 Program 
 [Prime number Founder 2.0] 
 [From] 
 $ (6) ($ 2 ^ 1) 
 [To] 
 $ (7) ($ 2) 
 {next} 
 $ (6) (6 $ ^ + 1) 
 $ (5) (6 $ @) 
 $ (4) (1) 
 {nl} 
 $ (4) (4 $ ^ + 1) 
 # ($ 6 ^ 4 $%) <l> 
 # (4 $ ^ 5 $ - |) <nl> 
 $ (2) ($ 6) 
 {l} 
 # (6 $ ^ 7 $ - |) <next> 
The search engine factorial. Using a recursive method. 
 define write = '$ (2)' 
 = {fac} = 
 ? [3] 
 $ (3) (g) 
 # ($ 3 ^ 1 -) <one> 
 * [3 ^ 1 $ -] <fac> 
 p (3 $ ^ g *) 
 ** 
 {one} 
 p (1) 
 ** 
 Program 
 * [2 $] <fac> 
 write (g) 
== Implementations == 
TOTOP3 - Stapler language interpreter written in Borland Pascal. 
== Links == 
* website Stapler-a
Category:Languages Category:Turing complete Category:2011 Category:Implemented
Stare

Stare, for Stack Rewriter, is a set of dialects of a declarative programming language designed by the Zodiac Working Group for rewriting... stacks. Yeah.
== Basic Idea ==
A Stare program operates on a stack with a rewriting system. At least in Stare 1.0, this works by continuously looping through the program, executing lines if and only if a certain condition about the stack is met. The instructions in these lines operate on the stack, making the language entirely stack-based. 
Stare is ostensibly declarative, but is, in reality, the most imperative declarative language you can get (or is it the other way around?)
== Dialects ==
There are (or will be) various dialects of Stare, similarly to how there are two different main dialects of Python (2 and 3). Each dialect introduces new features and may change the syntax. Different dialects are neither backwards- nor forwards-compatible.
=== Statically-typed ===
Statically typed Stare dialects existed before Dynamically-typed ones. If implementing a dynamically-typed Stare dialect, avoid starting with a statically-typed one and working forwards in updates from there. Instead, either implement directly from the most recent specification, or, if that seems overwhelming, implement from the earliest Dynamically-typed dialect.
==== 1.0 ====
Stare 1.0 is the initial dialect of Stare. It contains all the basic features and is the basis of all Stare dialects made by the ZWG.
===== 1.1 =====
Stare 1.1 introduced new syntax for lines. It makes certain types of code (that where you execute the same code on a set of values) easier and other types of code (where you execute only if certain values are both true or are different) possible.
===== 1.2 =====
Stare 1.2, which is currently in the design process, has so far introduced polymorphic values, which makes executing code if two values are the same possible.
==== 2.0 ====
Stare 2.0 is an upcoming Stare dialect. It introduces user-defined functions, libraries, and more!
=== Dynamically-typed ===
All Stare dialects from here on out are dynamically typed. Compiler makers beware.
==== 3.0 ====
3.0 is a far-future Stare update that introduces Basic OO.
==== 4.0 ====
Stare 4.0 is an update that may be so far in the future it postdates humanity (then again, if the Bulletin of Atomic Scientists is to be trusted, even Stare 2.0 may postdate humanity...). It inroduces more OO (and maybe some anonymous functions if you're good).
Category:Languages
Category:Stack-based
Stare/1.1

This article is the "What's New" document from the upgrade from Stare 1.0 to Stare 1.1.
== New Features ==
=== Syntax and Semantics ===
* In line conditions, | binary expressions are available. These execute if either condition is true.
* In line conditions, & binary expressions are available. These execute if both conditions are true.
* In line conditions, ^ binary expressions are available. These execute if either of their conditions are true, but not both.
* In line conditions, ! unary expressions are available. These execute if their condition is false.
* In line conditions, to account for having &, |, ^, and ! expressions, compound conditions can be grouped with parentheses.
Example of the new conditions:
 (_5 & #2)|!(_7^#12) = :::
This means: duplicate ToS three times if (SoS if 5 and ToS is 2) OR (not (SoS is 7 XOR ToS is 12)).
== Removed Features ==
None to report
== Changed Features ==
None to report
Stare/1.2

This article is the "What's New" document from the upgrade from Stare 1.1 to Stare 1.2. It is still a Work in Progress.
== New Features ==
=== Syntax and Semantics ===
* In line conditions, polymorphic values can be used to account for compound conditions. These work as such: If a name appears in place of a number in a condition, then count as true if all instances of that variable in this condition are the same. 
An example of this new element:
 _x & #x = :
This reads: Duplicate ToS if ToS is equal to SoS.
Starry

Starry, designed by Yutaka Hara in 2008 for his book, Rubyで作る奇妙なプログラミング言語, is a stack-based esoteric programming language. The book discusses the implementation of esolangs in Ruby; Starry is used as an example language.
==Syntax==
The only meaningful characters are space and +*.,`' -- all other characters are ignored. Each sequence of spaces followed by non-space character represents a single instruction.
==Instructions==
Spaces 	Final	Description
0 	+ 	Invalid opcode.
1 	+ 	Duplicate top of stack.
2 	+ 	Swap top 2 stack elements.
3 	+ 	Rotate top 3 stack elements.
4 	+ 	Pop top of stack.
n ≥ 5	+ 	Push n − 5 to stack.
0 mod 5 	* 	Pop y, pop x, push x + y.
1 mod 5 	* 	Pop y, pop x, push x − y.
2 mod 5 	* 	Pop y, pop x, push x * y.
3 mod 5 	* 	Pop y, pop x, push x / y.
4 mod 5 	* 	Pop y, pop x, push x mod y.
0 mod 2 	. 	Pop a value and print it as a number.
1 mod 2 	. 	Pop a value and print it as an ASCII character.
0 mod 2 	, 	Read a number from input.
1 mod 2 	, 	Read an ASCII value from input.
n 	` 	Mark label n.
n 	' 	Pop a value; if non-zero, jump to label n.
==Computational class==
Stack values are unbounded; using the swap, add, subtract, label, and "branch if non-zero" instructions, conversion from a 2-register Minsky machine is trivial. Therefore, Starry is Turing complete.
==Examples==
===Hello, world!===
 + + * + 
 * + . + + * + 
 * * + . + * + . + . 
 + * + . + + 
 * + * * + . + *
 + . + + * + * 
 * + . + * + . + * 
 + . + * + . + * + . 
 + + * + *
 * + .
===Fibonacci numbers===
 + + ` + + * +
 . + . + '
Disassembled:
 [[:push, 0],
 [:push, 1],
 [:label, 1],
 [:dup],
 [:rotate],
 [:+],
 [:dup],
 [:num_out],
 [:push, 10],
 [:char_out],
 [:dup],
 [:jump, 1]]
===99 bottles of beer===
 + + *` +. + + * . + + * 
 + * + . +* + . +* + . + . + * + . + * + . 
 +* + . + + * . 
 + * + . + * + . + 
 + * . + * + . +* + . + . +* + . + + * . + * + . 
 + * + . + + * . +* + . + * + . + * + . 
 + + * . +* + . + * + . +* + . . + . +. + + * . + 
 + * + * + . +* + . +* + . + . + * + . 
 + * + . +* + . + 
 + * . + * + . 
 + * + . + + * . + * + . +* + . + . +* + . 
 + . +* + . + * + . +* + . + * + . 
 + + * . +* + . + * + . + * + . + + * . + * + . +* + . +* + . + * + . + . +* + . + * + . 
 +* + . + . + + * . 
 + * + . +* + . + 
 + * . + * + . 
 +* + . + * + . +* + . 
 + * + . + * . 
 + . + * +. + + * . + + * + * + . +* + . +* + . + . + * + . 
 + * + . +* + . + + * . + * + . + * + . + + * . + * + . 
 +* + . + . +* + . + 
 + * . + * + . + * + . 
 + + * . +* + . + * + . + * + . + + * . 
 +* + . 
 + * + . +* + . . + + . . +'
==See also==
* Grass
* KEMURI
* Whitespace
==External resources==
* Ruby implementation from the book on GitHub
Category:Languages
Category:Stack-based
Category:Implemented
Category:Low-level
Category:Turing complete
Category:2008
Stars

Stars is a Turing-complete esoteric programming language created by User:TheCanon2. Stars' syntax is composed entirely of asterisks and spaces, and is based on lambda calculus.
==Commands==
Stars has four commands.
Opcode	Command	Action
1 	* (x) 	λx.
2 	** 	applied to
3 	*** 	(
4 	**** 	)
Opcodes greater than 4 are all used for variables and function names.
==Examples==
===XKCD Random Number===
* ***** * ****** ***** ** *** ***** ** *** ***** ** *** ***** ** ****** **** **** ****
In lambda calculus:
λf.λx.f(f(f(fx)))
===True===
* ***** * ****** *****
In lambda calculus:
λx.λy.x
===False===
* ***** * ****** ******
In lambda calculus:
λx.λy.y
===A+1 problem===
* ***** * ****** * ******* ****** ** *** ***** ** ****** ** ******* ****
In lambda calculus:
λn.λf.λx.f(nfx)
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Unimplemented
Category:2024
Category:Functional paradigm
Starstuff

Starstuff is a (family of) programming language(s) by User:PixelatedStarfish. It is designed such that an arbitrary sequence of characters can be interpreted as source describing a program, including ASCII art, source written in other languages, and articles such as this one. This is accomplished by compiling source to a language usable for programming. This article will assume the source compiles to Astridec, but this is far from the only acceptable compiler possible. Many variations on Starstuff that compile to other languages are possible.
==Compiling==
Note that a starstuff compiler must be able to compile any sequence of printable characters to source without crashing, throwing errors, or failing to terminate on a finite sequence.
===Cumulative Compiler===
A cumulative compiler does the following:
*Reads each character in source and converts it to an integer.
*Accumulates positive integer values, such as the sum of all chars, the product of all chars, or even the number of all chars as in Lenguage
*Interpret as Astridec source.
===Modulo Compiler===
A modulo compiler does the following:
*Creates an ordered set of all operations P, such that each operation has an index p. 
*Reads each character in source and converts it to an integer I.
*Replaces each integer I with an opcode p in P such that p is equal to I modulo |P| (where |P| is the cardinality of P).
*Interpret as Astridec source.
===Decimal Compiler===
A decimal compiler does the following:
*Converts each character in source to an integer, and converts that integer to a string.
*Interpret as Astridec source.
==External Links==
*Java Interpreter
*Online Java Interpreter
Category:Languages Category:2021 Category:Implemented
Start-reset markup language

A start-reset markup language is a fairly common type of esoteric markup language supported by many primitive chat platforms (namely, IRC and Minecraft) that uses a "start formatting" and "reset all formatting" syntax for its markup. An example of this formatting type that uses the "\" character as a formatting starter is:
Syntax 	Effect
\u 	Underline all text starting from here
\b 	Embolden all text starting from here
\i 	Italicize all text starting from here
\[bg=#RRGGBBAA]	Set the background color of all text starting from here to #RRGGBBAA
\[fg=#RRGGBBAA]	Set the foreground color of all text starting from here to #RRGGBBAA
\r 	Reset all formatting to the default (transparent background, black foreground, no italic, bold, or underline)
This seems like an utterly stupid sort markup language- every time you reset, you have to start all formatting you want to continue over again- but it's actually used quite commonly, most notably in Minecraft and on IRC.
Category:Languages Category:Markup Languages Category:Implemented Category:Total Category:Unusable for programming