nyuuzyou/wikis huggingface dataset:
SLOS

SLOS is created by User:A that stands for Scripting Language that's Outstandingly Simple; it tries to create a scripting language (not an interpreted language) that is very esoterically simple. It is designed to reach a high score at scriptometer.
== Tools (45 points) ==
* Compilation & execution in 1 command(20 points)
* Shebang aware(15 points)
* program can be passed on command line (5 points)
* interactive interpreter (REPL) (5 points)
== Program lengths by language (aka Example programs) ==
=== Smallest (0 bytes) ===
=== Hello, world! (16 bytes) ===
. is printing something to the console. Here, it takes a string. Parentheses for functions are optional.
. "Hello World"
=== argv (4 bytes) ===
$1 means the 1st parameter of the command-line.
. $1
=== env (4 bytes) ===
$h is the home environment variable.
. $h
=== Test file exists (11 bytes) ===
x tests whether a file exists.
x /etc/mtab
=== Test file readable (11 bytes) ===
r tests whether a file can be read. If so, then it reads the file.
r /etc/mtab
=== Formatting (25 bytes) ===
= sets a variable to a constant as it returns that value. + returns the sum of two values, and - returns the difference of two values.
. a=1," + ",b=2," = ",a+b
=== System (35 bytes) ===
c calls an external program. ? is the if statement; it checks the truth value of the right parameter, and if this is true, execute the rest of the line. A checking can contain :, which is the else part. :? can be combined into ;.
(c false)?. "false failed"
. "done"
=== Sed in place (bytes) ===
w writes a string to a file, and it takes two parameters. e is the regex command; it replaces all occurances of the second parameter (in regex) in the first parameter to the third parameter.
w (e (r $1),"#*$",""),$1
== External links ==
Scriptometer-contains the definition that SLOS is based on
Category:2019
Category:Languages
Category:Unimplemented
SLang

suspicious-lang/slang/>_> is a new esoteric language created and being developed by JesseH. It is pronounced >_> or >_>. It is a table-based language; If that makes any sense.
==Language Overview==
===How it works===
Command	Description
<_> 	(<_>.x) - Changes stack being used to x.
>_> 	(>_>.x) - Goes up on the stacks x amount of times.
<_< 	(<_<.x) - Goes down on the stacks x amount of times.
> 	(>.x) - Adds x to the stack variable being used.
< 	(<.x) - Subtracts x to the stack variable being used.
>_< 	(>_<.x) - Prints x.
Every statement must be ended with a .
==Examples==
Test
 <_>.MAIN.
 >_>.1.
 >.1.
 >_>.1.
 >.5.
 >_<.MAIN.1.
 >_<.MAIN.2.
This will output
1
5
==Contributing==
===Github===
 Github here.
===IRC===
The Official IRC channel for suspiciouslang is ##jesseh on Freenode.
Category:Languages
Category:Implemented
Category:2013
SLet

<- Older version | Newest version
SLet 1 has no clear type, SLet 2 has limited commands, so the author created SLet 3!
==Data types==
In this esolang, there is 5 data types.
 Number: Fraction. Size is unlimited. Division by 0 is NaN.
 Boolean: true or false.
 Pair: A pair of objects. One former value and one latter value.
 Lambda: Just a lambda function.
 Set: The most common data type. Objects in a set is always sorted. Boolean < Number < Pair < Set < Lambda.
==Commands==
<nowiki>
==== Flow Control
for | For every object in set A, store it in variable named B, and execute lambda C.
while | While boolean A is True, execute lambda B.
do | Start define a lambda. End with "all".
call | Executes lambda A.
==== Input/Output
get-char | Get a character input.
put-char | Print a character.
input | Get a number input.
print | Print an object.
decprint | Print a fraction as decimal to the B'th digit.
==== Data structures and calculations
match | Make a pair. Returns (A,B).
combine | Makes a set with various objects by union. End with "all".
opposite | Not boolean A. Negate number A.
swap | Swap the two objects in pair A. Swap the numerator and the denominator in number A.
former | Former object of pair A. Numerator of number A.
latter | Latter object of pair A. Denominator of number B.
pack | Pack object A into a set.
exist | True if object A is a subset of object B.
reveal | Pick a random object from set A. Randomly choose an integer between the 2 numbers in pair A.
first | Returns the smallest item in a set.
add | Does addition between numbers.
or | Does OR between booleans.
multiply | Does multiplication between numbers.
and | Does AND between booleans.
intersect | Does intersection between sets.
divide | Does division between numbers.
floordiv | Does floor division between numbers.
modulo | Does modulo between numbers.
range | Python "range(A,B,C)". Returns sets.
filtrate | For every object in set A, store it in variable named B, if C is false, throw away the item.
size | The size of set A.
==== Variables
let | Set the variable named A to B.
==== Constants
true, false, empty, nan, infinity
</nowiki>
Strings can be written in double quotes. Use backslash for escape(\q is used for double quotes.). Comments are written between parentheses.
== Examples ==
=== Hello world ===
 for "Hello, world!" i do put-char latter i all
=== A+B problem ===
 print add input input
=== Truth Machine ===
 let a input let l do print 1 all while a l print 0
=== Calculate pi ===
Initialize:
 let a 2 let b 0 let c 1 let i 1 let f do let t add multiply i 2 1 let b add a b let b multiply b t let c multiply c t let a multiply a i let i add i 1 print divide b c all
Each iteration, run:
 call f
Category:Languages Category:Turing complete Category:2025 Category:Implemented
SLet (Old)

Oldest version | Newer version ->
This esolang has 5 data types:
 1.Set: e.g. {1,2,3}
 2.Instruction: e.g. Print "Hello, world!"
 3.List: e.g. [{1},{2},{3}]
 4.Boolean: True or False
 5.Nil: just like lua's
A program is written in 1 line. Comments are written between parentheses.
Symbols besides ( ) " and space are the same as space.
Commands are only
 let [variable name] [value]
 print [text/number] [value]
 if [condition1] then [a list of instruction1] {elif [condition2] then [a list of instruction2]} {elif [condition3] then [a list of instruction3]} {...} {default [a list of instruction]} endif
 loop [variable1] [value1] {[variable2] [value2]} {...} while [condition] do [a list of instruction]
 return [value]
 call [a list of instruction]
A single number is a set e.g.
 29 (this is a set {29})
To create a set or combine sets, use this:
 combine 29 30 31 all (a set {29,30,31})
To create a list, use this:
 list 29 30 31 all (a list [29,30,31])
 "Hello, world!" (a list of this string's ASCII)
Calculations:
 lv 0 a b (addition a+b)
 lv 1 a b (multiplication a*b)
 lv 2 a b (a to the b'th power)
 lvq1 0 a b (subtract b-a)
 lvq1 1 a b (division b/a)
 lvq1 2 2 b (sqrt(b))
 lvq2 2 2 b (log2(b))
 equal a b all (returns boolean type)
 contain a b all (returns true if a and b both have at least 1 value)
 is a [greater/less]than{orequal} b (returns boolean)
 intersect a b all (intersection of two sets)
 difference a b
 select a with [a boolean, use "this" as the object in a]
 
 index [index, start with 0] of [a list]
 replace [a list] from [index] with [another list]
 size [a list or set]
 
 nor [boolean1] {boolean2} {...} all
 
calculation is did between every 2 numbers in the set e.g.{1,4}+{5,6}={6,7,9,10}
use
 input [set/list/text]
to get input
= Examples =
Hello World
 list print text "Hello, world!" all
A+B
 list let a input set let b input set let c lv 0 a b print number c all
Truth machine (This program is written like Lisp for better understanding)
 {list
 {let in input set}
 {if {equal in 0 all} then {list
 {print number 0}
 all}
 default {list
 {loop i 1 while true do {list
 {print number 1}
 all}
 all}
 all}
Theoretically, this program prints Graham's number, but no computer in this world can compute this:
 list let g lv 5 3 3 loop d 1 while is d less than 64 do list let g lv lv 0 g 1 3 3 let d lv 0 d 1 all print number g all
Category:Languages Category:Unimplemented Category:2024
SMITH

SMITH, for Self-Modifying Indecent Turing Hack, is an esoteric programming language designed by Chris Pressey in 2000. It has no jumps whatsoever; the instruction pointer can only be incremented, and only by one instruction at a time. As a substitute for loops, the language allows code to be copied forward where it will be executed in the future.
SMITH was designed for two purposes: as a more powerful descendant of SMETANA, and to one-up Bullfrog's partial lack of jump instructions.
SMITH# is a descendant of SMITH which comes closer to being a Turing tarpit.
==Syntax and Semantics==
Syntactically, SMITH resembles assembly code on a generic microcomputer. The specific syntax was loosely modelled after an imaginary register machine language described in "Compilers: Principles, Techniques, and Tools" (a.k.a. the "Dragon" book.)
From this starting point, however, SMITH fails to include any branching instructions. It makes up for this by adding the instruction COR, which stands for "COpy by Register". The purpose of COR is to provide a way to copy previously-executed instructions from the program into storage from which the program will be executed in the future. In this way, repetition of execution of code can still be achieved, despite the lack of branches.
Conditional repetition can be achieved via the single register operand of COR, which controls how many instructions are copied. If this value is zero, no instructions are copied; this can be used to simulate failing to meet a condition, especially in conjunction with the MUL instruction.
Since implementing a loop in SMITH requires only that part of the program is copied past the end of the existing program, the case of overwriting existing program contents with COR was not considered during design. This behaviour was therefore undefined (and, in the reference interpreter, happened to be implemented contrary to reasonable expectations) until version 2.1 (a.k.a "version 2007.0722") of the language.
==Computational class==
When it was designed, SMITH was believed to be Turing-complete. It imposes no limit on the number of registers, nor on the amount of information each register may contain. Also, copying (possibly zero-length) sections of already-executed code forward should be strictly equivalent to looping and branching in conventional programming languages.
This remained unproved, however, until September of 2012. On September 9, Chris Pressey wrote a sketch of a proof that SMITH is Turing-complete which shows how a 2-symbol, 3-state Turing machine could be implemented in SMITH. (It is only a sketch because it leaves it up to the reader to extrapolate how to implement an arbitrary 2-symbol Turing machine.) On September 11 2012 Keymaker provided a method and a Python program for translating Minsky machines to SMITH, constituting a much more formal proof.
==External resources==
* 
* Perl implementation
* A slightly faster perl implementation with a syntax extension
Category:Languages
Category:Cell-based
Category:Turing complete
Category:Implemented
Category:Low-level
Category:Self-modifying
Category: 2000
SMITHb

SMITHb (or in other words, "SMITH FLAT") is an esoteric programming language invented by User:Zzo38. There is no GOTO or loops or such things as that. The program consists of a sequence of integers (of any size, positive, negative, or zero) and nulls (which are represented by *). The program executes only forward, repeatedly executing and deleting the command indicated by the first 2 elements of the sequence (which is one command). It can also act as a stack with the top of the stack at the end of the program.
There are sixteen different commands:
* *	Stop program.
0 *	Pop one number from top of stack, and output it.
* 0	Input a number and push to stack.
0 0	Change top element of stack, positive to negative, negative to positive, null to zero, zero to null
- -	If X is less than Y then duplicate elements from X to Y onto the top of the stack. (The X and Y values are -1 for the top, -2 for one below the top, -3 for two below the top, and so on.) If X is greater than Y then duplicate elements from Y to X onto the top of the stack in reverse order.
- +	Push result of element X of stack divided by Y, rounded toward zero (null if element X is null).
+ -	Swap element X after the command in the program (1= next element after current command, 2=next one after that, etc) with element Y of stack.
+ +	Execute command which is element X in program followed by element Y in program.
+ 0	Delete X elements from the top of the stack.
- 0	Delete element X from the stack.
+ *	Remove the top X elements of the stack, add them together and push the sum, if any terms are nulls then the answer is also null.
- *	Swap element X of the stack with the top element of the stack.
0 +	Duplicate the top element of the stack Y times.
0 -	If element Y of stack is zero or null then reverse the entire stack (after the current command is removed).
* +	Delete the next Y elements of the program.
* -	Reverse the order of the elements from Y to the top of the stack.
You are allowed to define macros name(value) and include them by typing name. You can include Unicode numbers for characters by putting them in quotation marks. You can also repeat by typing the number of times to repeat followed by the stuff to repeat in parentheses. Comments are a semicolon and all of the text until the end of the line.
==Examples==
Hello world program:
 12(0 *) * *
 "!" "d" "l" "r" "o" "W" 32 "o" "l" "l" "e" "H"
Cat program:
 2(* 0 0 * -6 -1)
==Computational class==
SMITHb is Turing-complete. It is possible to convert brainfuck programs into SMITHb.
==Interpreters and translators==
* A SMITHb interpreter in Perl.
* A SMITHb interpreter in C.
* A brainfuck-to-SMITHb translator written in Perl.
* A brainfuck interpreter in SMITHb created by converting dbfi to SMITHb.
Category:Languages
Category:Stack-based
Category:Self-modifying
Category:Turing complete
Category:Implemented
SML

Stack Manipulation language (SML) is an Stack based esolang thought up by User:Froginstarch
In this programming language, the only structure is THE STACK (if you couldn't guess). Variable are references to value on the stack, so you can imagine variables as a pointer to a value on stack.
==Instructions==
Instruction	arg/s 	Description
label: 	none 	defines a label that can be jumped to
push 	value 	pushes value (number or string) onto the stack
pop 	stack[0] 	pops the top value on the stack
add 	stack[0], stack[1]	pops and adds 2 numbers together
def 	var, value 	adds value to the stack and var points to value in stack
print 	stack[0] 	prints the top value on the stack
jump 	label 	jumps to the specified label unconditionally
jumpif 	condition, label 	pops top 2 values off stack, if condition is truths jump to label
getin 	none 	gets STDIN
==Examples==
===Hello, world!===
push "Hello, world!" 
print
Add more below :)
==Interpreters==
there are none as of now
frog :)
Category:Languages Category:Unimplemented Category:Stack-based
SNACBIT

SNACBIT is an information unit that has these possible states:
# Peanut butter cracker
# Cosmic brownie
# Cheezit
# Cheeto
# Dorito
# Tortilla chip
# Cheese cracker
# Potato chip
# Applesauce
# Peanut butter cup
# Pickle
There isn't an approved category for this yet, though.
Category:Data Types and Structures
SNOBOL5

SNOBOL5 is an update from SNOBOL4. More information can be found at http://snobol5.org .
Oregon SNOBOL5 is an open source implementation for 64bit Windows and Linux on x86 processors. SNOBOL originated in Bell Laboratories in the 1960's. 
The language is useful for string processing, pattern matching, and many other things. Particularly compact code is the norm. Sample programs, documentation and source code can be found at the site above.
The language interpreter is written in x86 assembly language. Those learning about assembly language may also be interested in the assembly procedures for creating both Windows and Linux executables. A debugging capability is included.
Category:Languages Category:Implemented
SPADE

SPADE is a programming language first conceived in August 2018 by User:Swampie27782 and User:KiloByte?. It was made for a 12th grade computer science project in order to create a compiler for it in C++, making it one of the only languages to have been created purely to be interpreted by another language.
The full form of SPADE is, during normal conversation, Simple Parsing Algorithm Developed using C++ Expressions. However, its official expansion is Sabaton Pannikin Argentiferous Demisang Exaugurate. As you can see, this expansion makes far more sense.
Further edits forthcoming! For a teaser into the language (a quine program),
 var a.
 a : "\\var a\.\\na \\: \\"\" ~a \"\\"\.\\np\\rint \\"\" a\.".
 print "\var a.\na \: \"" ~a "\".\np\rint \"" a.
First one to figure out what it does gets a reward! (It'll probably be like a thumbs up or something.)
Category:Languages
Category:Implemented
Category:2019
SPBCL

Simple program-based computing language (SPBCL) is a Turing-complete esoteric programming language developed by User:Notjohnconway that is based off of the simple 1-dimensional programs described in Stephen Wolfram's book A New Kind of Science. It is currently in development.
==Operators==
===Definition operator===
The definition operator := gives a function, number, or other value a label that can be called upon later in the program.
For example:
Input:
 label := Num[10,5]
 print[label]
Output
 Num[10,5]
===Equality operator===
The equality operator = takes a statement and outputs a truth value 0 or 1. It can be used in tandem with the if:/then operators.
Input
 print[1+1 = 3]
Output
 0
===if:/then operators===
The if: and then operators take an input (usually a truth value) and give an output based on that operator.
Input
 if:
 1+1 = 2
 then:
 print['true']
Output
 true
===print[x] operator===
The print[x] operator simply outputs x.
Input
 print['x']
Output
 x
==Values==
===Functions===
See: Simple programs
===Numbers===
Numbers are given in the form Num[b,v] in which b represents the base of the number (in base 10) and v represents the value of the number.
===Truth values===
Truth values are 0 or 1.
===Plaintext===
Plaintext values are statements and are given as ' arbitrary text '
==Simple programs==
===Cellular automata===
Cellular automata are given as Ca[s,r,i,g] in which s is the number of states, r is a rulestring, i is the input, and g is the number of generations to iterate it in base 10. It outputs the minimum number of cells needed to define the state (that is, all cells not given are taken to be state 0).
Input
 print[Ca[2,
SPL

:For the functional stack language, see spl. For the Shakespearean language, see Shakespeare.
SPL is an esoteric programming language invented by StelK around December 2005.
It is very similar to Brainfuck but it has some new instructions. It was made only as a hobby.
SPL can handle only integers.
==Command set==
The SPL command set is that of Brainfuck with some alterations.
Command	Description
> 	Move pointer right
< 	Move pointer left
+ 	Increment the byte at the pointer
- 	Decrement the byte at the pointer
. 	Output the byte at the pointer
, 	Input the byte at the pointer
[ 	Jump past matching ] if the accumulator is 0
] 	Jump back to matching [ unless the accumulator is 0
New instructions:
Command	Description
^ 	Load the current byte into the accumulator
$ 	Wait for an input and put it into the accumulator
% 	Put in the current byte the result of the current byte%accumulator
m 	Multiply the current byte by the accumulator
a 	Add the accumulator to the current byte
s 	Subtract the accumulator from the current byte
d 	Divide the current byte by the accumulator
& 	Terminate the program immediately
"..." 	Print the string literal enclosed in the double quotation marks
#...# 	Comment (non-nestable)
To print text you can simply put it between " and ".
Text between # and # is a comment. Comments can't be nested. (The current implementation allows you to match an [ or ] inside comments for interesting results.)
==Examples==
===Hello World===
The classic Hello, world! program is:
 
 "Hello World
 "
The newline character is also printed.
===Countdown===
This asks a number and prints the numbers between it and zero:
 "n: ",^[." "-^]"
 "
===Cat program===
An infinitely repeating cat program is implemented in the following:
 ,.^["
 ",.^]
===Truth-machine===
This program implements a truth-machine:
 ,.^[.]
===99 bottles of beer===
The following provides a “99 bottles of beer” program:
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 ^
 [
 ++
 ." bottles of beer on the wall.
 "
 . " bottles of beer.
 "
 "Take one down, pass it around,
 "
 -
 . " bottles of beer on the wall.
 
 "
 --^
 ]
 
 "2 bottles of beer on the wall.
 2 bottles of beer.
 Take one down, pass it around,
 1 bottle of beer on the wall.
 
 1 bottle of beer on the wall.
 1 bottle of beer.
 Take one down, pass it around,
 No bottles of beer on the wall.
 "
==See also==
* Brainfuck: The language from which SPL is born.
==External resources==
* Author's home page (ITA) (Includes somewhat buggy implementation.) 
==Interpreter==
* Common Lisp implementation of the SPL programming language.
Category: Languages
Category: Brainfuck derivatives
Category: Implemented
Category: 2005
Category: Cell-based
Category: Low-level
SPLEMIT21

SPLEMIT21 (short for Shortest Programming Language Ever Made In The 21st [Century]) is a joke language developed by Maximilian Krause aka fucketh1cs. SPLEMIT21 was solely made to cheat on several tasks like quines.
== Commands ==
Symbol	Feature
H 	Prints "Hello world!"
Q 	Prints the source code of the program. See Quine.
C 	Takes an input and prints it again. See Cat program.
T 	Takes an input and prints "0" if it's 0, if it's 1 it goes into an infinite loop printing 1. See Truth-machine.
9 	Prints the lyrics of 99 bottles of beer.
== Example code ==
Prints "Hello world!", prints "HQ" (its own source code) and then terminates.
HQ
== External resources ==
Official interpreter (Java needed): https://www.dropbox.com/s/adnxq9vh1jx05hz/splemit21.jar?dl=0 
Source code: https://github.com/fucketh1cs/SPLEMIT21 
Category:Languages Category:Unusable for programming Category:Joke languages