nyuuzyou/wikis huggingface dataset:
Slashist

Slashist is a language created by User:Dittoslash.
Slashist is written with lines of three letter commands.
==Commands==
VAR:(varname):(initial value) ~ Creates a variable (varname) with value (initial value) (string or num). 
ADD:(varname):(num) ~ Adds (num) to variable (varname) 
SUB:(varname):(num) ~ Takes (num) away from variable (varname). 
LOP:(id) ~ Starts loop with (id), could be taken as a jump label. 
ELP:(id) ~ Jumps to LOP with same (id). (ID) is three characters ONLY. 
CEL:(id):(con) ~ Jumps to (id) if (con) is 1. 
NCL:(id):(con) ~ Above, but if (con) is 0. 
OUT:(varname) ~ Writes (varname) to output. 
WRT:(something):(varname) ~ Set (varname) to the value of (something) (string or num or var). 
INP:(varname) ~ Set (varname) to string from input, enter must be hit to confirm input 
NUK: ~ terminate program 
==Constants==
Strings are enclosed in quotation marks: "string" 
Numbers are enclosed in curly brackets: {0} 
Variable are written within tags: <name> 
Conditions (for (con) arguments) are written like this: [{0} = {1}] (which returns 0). Only = and != (not equals) can be used in conditions (and of course strings, vars, and nums) 
Note: Only numbers, strings, and variables can be used in conditions. 
==Cat program==
VAR:<inp>:"" 
INP:<inp> 
OUT<inp>
==Truth machine==
VAR:<choice>:"" 
VAR:<ZERO>:{0} 
VAR:<ONE>:{1} 
INP:<choice> 
NCL:ZRO:[<inp> = {0}] 
CEL:ONE:[<inp> = {1}] 
LOP:ZRO 
OUT:<ZERO> 
NUK: 
LOP:ONE 
OUT:<ONE> 
ELP:ONE
Category:Languages Category:Unimplemented
Sleep.

: Not to be confused with Sleep
Sleep. Is an esoteric programming language created by User:Buckets, just about Sleeping made in 2024.
Command	Instruction
Sleep 	Sleep
Sleep:
 Sleep
Extra Sleep:
 Sleep Sleep
This program does nothing, not even Sleep:
 Thisprogramistoshowthatthisesolangcandosomethingelseotherthansleep
Not a "Hello, World" Program:
 Sleep Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep
Not a Truth-Machine program:
 Sleep Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep Sleep Sleep 
 Sleep Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep Sleep Sleep 
 Sleep Sleep Sleep Sleep
 Sleep Sleep Sleep Sleep Sleep
Are you realising yet that this entire Esolang is just a joke?:
 Because hypothetically I can do this forever.
Oh wow! A Program that may or may not Have the Command 'Sleep':
 Sleep
Joke Program:
 Sleep
Sleep:
 Sleep
Sleep?:
 Sleep ?
Sleeeeeeeeep:
 Sleep Sleep Sleep Sleep Sleep Sleep Sleep 
 Sleep Sleep Sleep Sleep Sleep Sleep Sleep 
 Sleep Sleep Sleep Sleep
No Sleep:
 Is bad.
Filler:
 Sleep
Not a Sleep Interpreter:
 Sleep
Not a Sleep. Interpreter:
 Sleep
Will this Page get Deleted?:
 I don't know, Probably?
 I mean, this is just a really
 Really long joke about an
 Esolang I made like A year ago
 And I thought "Hey, what If
 I just mess around?"
 So... Yeah, Probably
 This page will get deleted, Probably.
 But that's not a promise,
 I can't predict the future.
 Sleep
Not a FizzBuzz Program:
 Sleep Sleep
This program Is purely Filler:
 Filler
Not a Cat program:
 Sleep Sleep Sleep Sleep Sleep Sleep
Not a Program proving That Sleep. Is turing Complete:
 Sleep Sleep
Is User:Buckets Either being Unproductive and or Procrastinating?:
 ...
 What kind of Question is that?
 Of course I am.
 Sleep
Not a Program proving That Sleep Is turing Complete:
 Sleep Sleep Sleep Sleep
A Song/Program that your Unresting Baby or Child might Fall asleep to:
 Sleep Sleep Sleep Sleep Sleep Sleep 
 Sleep Sleep Sleep Sleep Sleep Sleep Sleep Sleeep
 Chorus: Please child or Baby, Please. Sleep Sleep Sleep
 Sleep! I need to Sleep Sleep Sleep Sleep Sleep, So Baby or Child Please.
 Sleep Sleep Sleep Sleep Sleep Sleep 
 Sleep Sleep Sleep Sleep Sleep Sleep Sleep Sleep! Sleep Sleep Sleeeep
 Sleep Sleep Sleep Sleep Sleep Sleep Sleep.
 Chorus: Please child or Baby, Please. Sleep Sleep Sleep
 Sleep! I need to Sleep Sleep Sleep Sleep Sleep, So Baby or Child Please.
 Sleep! Sleep! Sleep! Please! Sleeep.
Is there any Deeper meaning to this?:
 No, It's just A really Really long joke.
 Why did you ask this Question?
 I just thought It would be funny, That's it.
 Sleep
: You can help User:Buckets By Continuing this awful joke far far into the future, you could join Hypothetical Generations and generations to contributing with this Terrible joke by [ Adding more programs that Sleep. can't Do].
Category:2024
Category:Languages
Category:Joke languages
Slide

Slide is an esoteric programming language created by Tanner Swett in 2014.
A Slide program consists of a two-dimensional array of spaces, hash symbols ('#'), and lowercase English letters. A space denotes an empty space, a hash denotes an immovable barrier, and a letter denotes part of a movable object. If two of the same letter are orthogonally adjacent, then the two letters are connected; an object is a connected component of letters.
The initial state of a program is a two-dimensional array infinite in all directions, with the program itself somewhere in the array. Execution proceeds by selecting an arbitrary object and an arbitrary orthogonal direction. The object is moved as far as possible in that direction without it overlapping a barrier or another object. If this would result in the object moving infinitely far, the object instead is not moved. (Separate objects remain separate, even if two objects using the same letter come into contact.)
If an object whose letter is "h" ever moves, the program halts immediately after its motion completes.
Category:2014
Category:Languages
Category:Unknown computational class
Category:Unimplemented
Slide-rule completeness

A machine is slide rule-complete if said machine can perform any operation that can be simulated by a slide rule of arbitrary length with arbitrary markings.
==Slide rule machine==
A slide rule machine is an automaton that operates by moving a sliding scale c relative to two fixed scales, d_{1} and d_{2}, according to a set of rules.
All unary functions can be simulated by a slide rule machine.
Category:Concepts
Slim

Slim is a minimalistic stack-based esoteric programming language designed by User:Scoppini in 2015.
==Overview==
Slim operates on a stack of Boolean values, which starts out completely empty. The commands are:
Command	Description
0 	Push a zero onto the stack.
@ 	Flip the top bit of the stack, and send it to the bottom.
< 	Move the bottom bit of the stack to the top.
X 	Pop the stack.
^ 	Output the top bit to the output stream (bits are output in big-endian order).
 	Push a bit of input onto the stack (also in big endian order).
: 	If the top bit is 0 or the stack is empty, do nothing. Otherwise, pop the stack as long as the top bit is 1 and the stack isn't empty. After the stack has finished being popped, jump to nth : in the code, where n is the number of times the stack was popped.
==Examples==
===Hello, World! program===
 0^@^@^^@^@^^^
 ^@^^@^^@^@^@^
 @^@^^@^@^^@^^
 ^@^^@^@^^@^^
 ^@^^@^@^^^^
 @^^@^@^^^^^
 ^@^@^@^@^@^^^
 @^@^^@^@^^^^
 @^@^^^@^^@^@^
 ^@^^@^@^^@^^
 ^@^^@^^@^@^^
 ^^@^@^^^^@^
 @^^^^@^@^@^@^
===Cat program===
 0@0@0@0@0@0@0@0@0@
 :0@^|^X|^X|^X|^X|^X|^X|^X0@0@0@0@0@0@0@0@
 :0^@^|^X|^X|^X|^X|^X|^X0@0@0@0@0@0@0@0@
 :0^^@^|^X|^X|^X|^X|^X0@0@0@0@0@0@0@0@
 :0^^^@^|^X|^X|^X|^X0@0@0@0@0@0@0@0@
 :0^^^^@^|^X|^X|^X0@0@0@0@0@0@0@0@
 :0^^^^^@^|^X|^X0@0@0@0@0@0@0@0@
 :0^^^^^^@^|^X0@0@0@0@0@0@0@0@
 :0^^^^^^^@^0@0@0@0@0@0@0@0@
 :|:@|:@|:@|:@|:@|:@|:@|:
===Truth-machine===
 0@0@0@0@0@0@0@0@0@|
 :X|
 :X|@<
 :X|@<
 :X|
 :X|
 :X|
 :XX|
 :^^@^^@<^^^^@0@
 :0^^@^^@^^^@^0@0@0@0@0@0@0@0@
 :
==External resources==
* Interpreter written in python
Category:Languages
Category:Implemented
Category:Stack-based
Category:2015
Slimey

Slimey is an esolang created by User:Tommyaweosme based off of the cellular automaton Sticky.
== Commands ==
 > thing going right
 ^ thing going up
 v thing going down
 < thing going left
 0 numberificator
 p thingificator
 ┓ turns
 ┗ turns
 ┏ turns
 ┛ turns
 
 ━	splits
 ┃ splits
 ▓ draggable (also splits in every direction)
 O outputs
 I input (turns into numberificator with that value)
 d[ diode (only accepts coming in from right)
 ]d diode (only accepts coming in from left)
NOTE: The numberificator loses 1 value for each photon released. Duplication hacks like the one shown below does not work.
 p
 9p
 p
It shoots 3 photons in the directions instead of 9.
It also loses 1 value for each output. Also duplication hacks don't work on this either.
== Scripts ==
=== Cat ===
 IO
=== Truth Machine ===
 Ip ]d━┓
 ┗━ 0o
=== Infinite loop ===
 ┏┓
 v
 ┗┛
Slindow

Slindow is an esoteric programming language invented by User:A that makes it easy to solve sliding-window challenges. Inspired by this challenge.
== Built-ins ==
Slindow automatically pushes all input as atoms([1 2 3] counts as 1 array atom and 1 counts as 1 integer atom/a length-1 array atom.) The top of the stack is outputted by default.
* Cut the top of the stack to the accumulator.
/ Paste the accumulator's value to the stack.
array: Push the indicated array. If the length is 1, you don't need brackets.
} Start a for loop that iterates the length of the top of the stack times, popping the item.
' Put the top-array's back item to the front.
" Put the top-array's front item to the back.
~ Return the nth prefix of the second top-of-stack; n is the top of the stack.
` Return the nth suffix of the second top-of-stack; n is the top of the stack.
w Return the sliding-windows of the bottom of the second-to-top atom with a width of the top of the stack.
{ Starts a for loop iterating over each item of the top of the stack, popping the item.
. End a loop
m Return the minimum of the current item as an array atom
M Return the maximum of the current item as an array atom
+ Concatenate the top two items into an array
@ Apply the effect onto the whole stack instead
- The difference between the top two items
== Sliding-window minimum challenge ==
*}/~m@'1~-.@+
Category:Languages
Category:2019
Category:Unimplemented
Slink

Slink is the first programming language made by User:3xcpy.
== Overview ==
In Slink, execution takes place on a fixed-size 3-element stack (stack in the sense that instructions operate on the top element(s)).
You can put other fixed-size 3-element stacks on the current stack.
Flow control is done with conditional jumps.
=== Operations ===
Operation	Meaning
$n 	Put the number n in the top slot of the current stack.
?n 	Jump to operation n if the top element of the current stack is 0, where n is zero-indexed.
#n 	Jump to operation n (unconditionally). Zero-indexed.
& 	Rotate the 3 stack elements as follows: ( a b c -- c a b )
+ 	Add the top two elements of the current stack and put the result into the top slot.
> 	Move execution to the stack that is located in the top slot of the current one.
< 	Move execution to the stack that the current stack is located on.
^ 	Create a new 3-element stack in the top slot of the current one and initialize all the elements to 0.
, 	Read one character from STDIN and put its value in the top slot of the current stack
. 	Treat the top value of the current stack as an ASCII-encoded character and print it to STDOUT.
% 	Print the top value of the current stack as a number.
=== Notes ===
* % and # are technically not required, but programming without them is a pain, which is why they were added.
* For programs that need unbounded memory, Slink is pretty similar to brainfuck in that you usually have a tape made of stacks on stacks on stacks etc (like a doubly-linked list) and you walk back and forth on it, like on the tape in brainfuck. 
* I wanted to make the stacks only have 2 slots, but that would just be Brainfuck (all operators act on one value, you walk back and forth on this linked list).
* There is probably a much simpler and more elegant instruction set for such a language.
* Translations from Brainfuck should be trivial (the tape is made up of linked stacks, and you walk back and forth on it, adding and subtracting from the values).
* The language originated from wanting to experiment with fixed-size stacks (8-ish elements) and recursive ones, but to make the "recursiveness" a central part of the language, the stacks had to be as small as possible, which is how it basically turned into a Brainfuck derivative.
:* Although I can imagine having multiple branching chains of stacks could be way more useful than just a simple tape.
--3cxpy (talk)
== Examples ==
=== Hello World ===
 $72.$101.$108..$111.$32.$87.$111.$114.$108.$100.$33.
=== Cat ===
 ,%#0
=== Truth machine ===
 ,&$-48+?8$1%#6$0%
== Links ==
Example implementation (unfinished)
Category:Languages
Category:2024
Category:Stack-based
Category:Cell-based
Category:Turing complete
Slistp

slistp is small list processing programming language. Data is only lists and numbers (integers). Lists can contain lists and numbers. Functions are also represented as lists.
All numbers in the syntax are separated by semicolons and lists are delimited by square brackets.
Macros can also be specified by the name and an equal sign and then the definition and a semicolon. Macros can define other macros, but these are processed only during the preprocessor stage. Macros defined inside of a list are local to that list (again, only during the preprocessor stage).
Strings can be specified in quotation marks and they act the same as a list of their ASCII numbers.
"#" mark denotes a comment up to a line break.
The program is given as a list, which is a function. Each function takes one parameter and returns one value, which is the current value. Also each function has one auxiliary value which is initialized to the second element of the function list when the function is started. (The first and second elements is not used as a command.)
Commands:
* 0 = No operation.
* 1 = Add together all numbers in the current list (recursively).
* 2 = Multiply together all numbers in the current list (recursively).
* 3 = Calculate the average of all numbers in the current list (recursively), rounded down.
* 4 = Enclose the current value in a list of one element.
* 5 = Swap the current value with the auxiliary value.
* 6 = Make the current value into a list with two elements, the first being the old current value and the second being the auxiliary value.
* 7 = Loop to the beginning of the function outer of this one, using the current value of this function as that function's current value.
* 8 = Execute the command from the auxiliary value.
* 9 = Unthrow, or exit this function if the current position in this function is not from a thrown exception. When you unthrow the current value will change to this function's current value.
* Even numbers greater than 9 = Mark a point to catch thrown exceptions.
* Odd numbers greater than 9 = Throw an exception to the number one less than this one, this function's current value becomes the result and that function continues from the thrown part.
* Negative numbers = Add this number to the auxiliary value or all elements of the auxiliary value.
* List = If the first element of this list is a list not containing any copy of the current value, and the current value is a list, run that function on the elements of the current value, with the parameter being a list containing the list index (zero-based) as its first element and the value of the element being processed as the second element, with the return values which are lists being concatenated together in order to determine what the new current value will become.
Category:2010
Category:Unimplemented
Category:Languages
Sm

Sm is an esolang based on Smu, with comments removed.
* () Push a string to the stack. The string is whatever is inside the parentheses, you can have nested parentheses but it must be nested correctly. Only the characters ()=|+ can be inside a string, other characters are ignored or are processed by the preprocessor.
* = Pops two strings from the stack, and sets the variable with the name specified by the first string (the top value) to the value specified by the second string. Does nothing if not enough strings on the stack.
* | Splits a string into a head and a tail and pushes them onto the stack (tail first, the head will then be at the top of the stack). If the string is empty then it will pop it from the stack without pushing anything. Does nothing if stack is empty.
* + Pops two variable names from the top of the stack and joins their values. Value at top is the name of variable which is the value at end of the string, second from top is the beginning of result string. Does nothing if not enough strings on the stack.
Smalc

Smalc is a joke calculator (created to be better than Desmos) implemented as a project to learn Elixir.
Created by User:Joe
==Spec==
===Literals===
There are no number literals in the calculator, only identifiers. If an identifier can't be found in the context, it's then treated as a base 16 number. 
The language was implemented this way so you could redefine the values of numbers. 
===Operators===
What the math operators correspond to in Smalc:
All operators are right-associative as well. 
Operator	Type 	Symbol 	Precedence
+ 	prefix 	min 	60
- 	infix 	max 	70
* 	postfix 	+ 	50
/ 	infix 	- 	40
pow 	mixfix (a S b c)	extrema	30
mod 	prefix 	@ 	80
sqrt 	postfix 	sin 	NONE
===Preprocessor===
Before the program is interpreted, every [ in the text is replaced with ((( and every ] is replaced with )).
===Brackets===
Expressions can be bracketed with mismatching (, ), [, ], {, }. But because of the way they're implemented in the parser, you can't nest bracketed expressions lol. 
===Variables===
Variables are defined as such:
 : expr ident : expr
Identifiers are any sequence of alphanumeric characters.
When accessing a variables, you reverse the name. A variable defined as PI would be accessed as IP.
== Examples ==
 (((1400 * 1000000) / 1) - 16) + 4000000
is equivalent to 
 min {578 F4240 + - 1) max 10 3D0900
in Smalc.
==Implementation==
Interpreter in Elixir with repl
Category:Joke_languages Category:Unusable_for_programming Category:Unknown computational class Category:Output only Category:Implemented Category:Languages
Small SNUSP

== Description ==
Mostly harmless.
 \ LURD If going
 left, go up
 up, go left
 right, go down
 down, go right
 / RULD If going
 right, go up
 up, go right
 left, go down
 down, go left
 ! SKIP Move the instruction pointer forward one step
==History==
SNUSP was invented around September 2003 by Daniel Brockman, shortly after the release of PATH the previous month. A working draft of a language specification was published, but the final specification (version 1.0) has not been written.
Small SNUSP was invented around April 2015
== Example: Infinite loop ==
$!/\
 \/
== See also ==
* SNUSP
* PATH, extensions to Small SNUSP.
Category: Two-dimensional languages
Category: Cell-based
Category: No IO
Category: Languages
Category: 2015
Smaller

Smaller is an OISC by User:ChuckEsoteric08.
==Command==
 a;b;
Add value b to variable a and if result was zero back to the start of the program. To increment variable by other variable, you need to put it inside two "%"s. It is also possible to have multiple operations like that:
 a;2-1;
Increment a by 1
==Examples==
===Jump unconditionaly one time===
 a;-%a%;
==See Also==
*Addleq
*AddJump
*P1eq
*OISCalypse
==Computational class==
When variables are allowed to take on arbitrarily large values, Smaller is Turing complete because Brainpocalypse II (in its numerical view) can be compiled into it.
The main subtleties in the construction:
* Smaller variables are 1 higher than their Brainpocalypse II counterparts. This prevents the program being accidentally sent back to the start when doing a no-op on a variable by increasing and decreasing it again.
* To compensate for this, a decrement is implemented by subtracting 2 from the variable, and then adding 1. (Additions are implemented directly.)
* Each variable has an "auxiliary variable" that remembers whether the code reset during the decrement of that variable. Auxiliary variables are 1 while the variable is not being decremented, and 3 while it is (you add 2 to the auxiliary variable immediately before a decrement, and subtract 2 again afterwards).
* At the start of the program, each variable has its auxiliary variable minus 2 added to it (this implements the way that Brainpocalypse II variables increment rather than decrement when being decremented from zero). Then all the auxiliary variables are set back to 1 (by subtracting 1 minus themself).
All other aspects of Brainpocalpyse II can be compiled directly.
==External resources==
Compiler to Batch
Category:Languages Category:Implemented Category:OISC Category:Turing complete
Smallfuck

Smallfuck is an esoteric programming language invented by Nikita Ayzikovsky around March 2002 for the purpose of compiling it to SMETANA. It is a sized-down version of Brainfuck that operates only on bits, has limited data storage, and does not define input or output.
==Command set==
The Smallfuck command set is that of Brainfuck with two alterations: . and , are omitted, and + and - are replaced by * (because, when applied to bits, + and - would do the same thing anyway.) The command set is summarized as follows:
 > Move pointer right
 < Move pointer left
 * Flip current cell
 [ Jump past matching ] if cell under pointer is 0
 ] Jump back to matching [
If a program attempts to move the memory pointer to the left of the first cell, or to the right of the (implementation-defined) last cell, it terminates normally.
Because input and output are not defined, it is generally assumed that input is encoded in the initial state of the data storage, and that output must be decoded from the final state of the data storage.
==Computational class==
If we were to grant Smallfuck an unbounded tape, we could show it to be Turing-complete by a trivial reduction from Boolfuck. All that is missing are I/O commands, which are not required for Turing-completeness.
However, while the number of bits in Smallfuck's data store capacity is completely left up to each implementation, the number is defined to be finite. Thus, Smallfuck is in the computational class of bounded-storage machines with bounded input.
==See also==
* Boolfuck is a similar language but is equipped with input and output.
* Nanofuck an invertible minimization of Boolfuck.
* BitChanger combines two more instructions. 
* BF instruction minimalization chronicles one author's attempts at a smaller Brainfuck.
* Braktif is a formulation of Smallfuck as a cellular automaton.
* Fm languages; F2 can be seen as a Turing-complete extension of Smallfuck.
* SMETANA, to which Smallfuck can be compiled.
* RCEM, to which Smallfuck can be translated. RCEM is Turing-complete.
* Smallfuck/sf2wikitable
* Smallfuck/smf.rhk implements a memory-unbounded version of Smallfuck in Rhokell as a proof of its turing-completeness.
==External resources==
* is a Smallfuck-to-lookup-table compiler.
* Possible Smallfuck interpreter
* sf2wikitable - smallfuck to wiki table compiler
Category: Languages
Category: Brainfuck derivatives
Category: Cell-based
Category: No IO
Category: 2002
Category: Bounded-storage machine
Category:Implemented
Smallfuck/sf2wikitable

:
Here is an some programs compiled to wiki tables
==Program:>*>*[*<], tape lenght:8==
Command number	State of program(running or halted)	Current symbol in program(>*>*[*<])	Tape 	Pointing to cell:
1 	Running 	> 	00000000	1
2 	Running 	* 	01000000	1
3 	Running 	> 	01000000	2
4 	Running 	* 	01100000	2
5 	Running 	[ 	01100000	2
6 	Running 	* 	01000000	2
7 	Running 	< 	01000000	1
8 	Running 	] 	01000000	1
6 	Running 	* 	00000000	1
7 	Running 	< 	00000000	0
8 	Running 	] 	00000000	0
9 	Halted 	Out Of Bounds 	00000000	0