nyuuzyou/wikis huggingface dataset:
SVM

SVM is an esoteric programming language by user:David.werecat that works as a virtual machine with expandable memory.
==Data types==
Data types are represented as follows: (1 character for data type)(n characters for reference)
Data type 	Char code	Address representation	Use
immediate 	= 	8 hex chars 	is an integer which is specified in the program data
memory 	* 	8 hex chars 	references a memory location
register 	! 	2 hex chars 	references an integer register
stack 	^ 	n/a 	uses the stack
queue 	~ 	n/a 	uses the queue
pointer 	@ 	n/a 	uses the pointer variable to reference a memory location
imm. string	$ 	? chars 	is a string which is specified in the program data
==Instructions==
Commands are two letters in length and are represented as follows: (2 character command)(1 space character)(parameters comma separated)(newline).
Command	Parameters	Description 	Exceptions
AM 	1 	expands memory by P1 	n/a
RM 	1 	shrinks memory by P1 	Lowest possible memory size is 16
IP 	1 	increments pointer by P1	n/a
DP 	1 	decrements pointer by P1	Pointer cannot go below 0x00000000
PV 	1 	pointer value -> P1 	P1 must be a memory pointer, limited by size
M+ 	3 	P3=P1+P2 	Always integers
M- 	3 	P3=P1-P2 	Always integers
M* 	3 	P3=P1*P2 	Always integers
M/ 	3 	P3=P1/P2 	Always integers
M^ 	3 	P3=P1^P2 	Always integers
AD 	3 	P3=P1 AND P2 	Always integers
OR 	3 	P3=P1 OR P2 	Always integers
XR 	3 	P3=P1 XOR P2 	Always integers
NT 	2 	P2= NOT P1 	Always integers
CM 	3 	mem P1 size P2 -> mem P3	Limited by maximum memory size
ZM 	2 	zeros mem P1 size P2 	Limited by maximum memory size
IC 	1 	user keycode -> P1 	n/a
II 	1 	typed integer -> P1 	n/a
IL 	1 	typed line -> P1 	Doesn't copy if memory overflow
DD 	2 	displays text P1 size P2	n/a
DI 	1 	displays integer P1 	n/a
DC 	0 	clears display 	n/a
## 	0 	COMMENT 	n/a
GT 	1 	jumps to instruction P1 	P1 is the logical instruction number
SK 	1 	jumps to instruction P1 	P1 is the offset from the current instruction
IG 	4 	if P1 P2 P3 then GT P4 	P2 is a predefined comparator (integer)
IS 	4 	if P1 P2 P3 then SK P4 	P2 is a predefined comparator (integer)
WT 	1 	waits P1 miliseconds 	P1 is an integer
BP 	0 	beeps 	n/a
EP 	0 	ends program 	n/a
Note: In the examples, whenever a value like P1 appears, it represents a parameter.
 Comparators
Value 	Comparator
0x00000000	=
0x00000001	<>
0x00000002	<
0x00000003	>
0x00000004	<=
0x00000005	>=
==External resources==
* Visual Basic .NET interpreter and sample programs
Category:Languages
Category:2012
Category:Unknown computational class
Category:Implemented
SWING

SWING is an esoteric programming language created by Alan Kubiak, written in DPL.
== Characteristics ==
The SWING programming language works using numerical values only.
== OPCodes ==
ADD: 120
MINUS: 140
MULTIPLY: 160
DIVIDE: 180
MODULO: 200
EQUAL TO: 220
SMALLER THAN: 240
BIGGER THAN: 260
NOT EQUAL TO: 280
END: 500
UNCONDITIONAL JUMP: 700
PUSH VALUE: 300
PRINT: 800
CALCULATION: 900
INPUT: 400
RANDOM: 600
SLEEP: 50
IF: 10
END IF: 20
PAUSE: 30
REMARK: 0
== SWING Virtual Machine ==
The SWING virtual machine interprets the OPCodes and the arguments line by line.
== Examples ==
Remark
0
 This is a remark. It is not interpreted by the virtual machine.
Hello, World!
0
 SWING @ Hello, World
300
 1 
 50
300
 2 
 50
10
 1 
220
 2
300
 1 
 72
300
 2 
 101
300
 3 
 108
300
 4 
 108
300
 5 
 111
800
 1
800
 2
800
 3
800
 4
800
 5
300
 1 
 44
300
 2 
 32
300
 3 
 87
300
 4 
 111
300
 5 
 114
800
 1
800
 2
800
 3
800
 4
800
 5
300
 1 
 108
300
 2 
 100
300
 3 
 33
800
 1
800
 2
800
 3
20
500
Counting program
0
 SWING @ Counting Program
300
 1 
 0
300
 2 
 1
400
 3
300
 4 
 777
900
 1 
120
 2 
 1
800
 1
10
 1 
220
 3
300
 1 
 0
700
 33
20
700
 14
800
 4
500
Devine game
0
 SWING @ Devine Random Value
600
 5 
 100
400
 4
0
 FOUND
10
 4 
220
 5
800
 777
300
 3 
 50
20
0
 TOO SMALL
10
 4 
240
 5
800
 300
20
0
 TOO BIG
10
 4 
260
 5
800
 400
20
0
 CHECK FOUND
10
 3 
280
 50
700
 6
20
500
== External resources ==
* Website
* GitHub repository
Category:Languages
Category:Unknown computational class
SWhoopieenddns

(pronounced "Whoopie!".)
==Types==
===Number===
n starts and stops a number. The letters abcdefghij correspond to the digits 0123456789. For example, nddn is 33.
===String===
s starts and stops a string. e is used to escape anything. To put non letter/space characters, use numbers (inserting the UTF-8 char(s)) or functions. To insert a number, use the normal number syntax. To insert an expression, use l (left parens) and r (right parens). sHeeelelol asciilneenr r worldl asciilnddnr rs is "Hello{ascii(44)} world{ascii(33)}", which is just hello world. (A shorter possibility is using numbers directly sHeeeleloneen worldnddn.)
==Calling Functions==
printl sSupnddns r
S and K Turing-completeness proof

Many esoteric programming languages in the functional paradigm use the S and K combinators to demonstrate that they are Turing-complete. This page outlines a proof that the S and K combinators are Turing-complete, by showing that any expression in Lambda calculus can be converted into these combinators.
Currently missing is an argument that the conversion preserves the respective reduction/evaluation semantics of the computation models.
==Conversion==
We begin by observing the following equivalences:
* Ky = (λ x.y)
* (SKK) = (λ x.x)
* (S(λ x.f)(λ x.g)) = (λ x.fg)
* y = (λx.yx) (Eta conversion)
We can apply these in reverse to convert a lambda expression into combinators. Note that the final rule can convert longer expressions - for example, λ x.abcdeg can be converted by setting f = abcde. This will eventually terminate as the third rule reduces the number of applications, so that eventally one of the other rules will take effect and remove the lambdas.
==Example==
Consider the following lambda expression, which raises one Church numeral to the power of a second:
λ mn.nm
Recall that this is short-hand for:
λ m.(λ n.nm)
Which by the third rule becomes:
λ m.S(λ n.n)(λ n.m)
Which by the first and second rules becomes:
λ m.S(SKK)(Km)
Which by the third rule becomes:
S(λ m.S(SKK))(λ m.Km)
Then by the fourth rule, the last statement becomes K:
S(λ m.S(SKK))K
Then by the first rule, the statement becomes:
S(K(S(SKK)))K
Which is the combinator form of (λmn.nm).
==See Also==
*Combinatory logic
==External resources==
*wikipedia:SKI combinator calculus
* David Madore's original description of the Unlambda language
* Raymond Smullyan, To Mock a Mockingbird
Category: Proofs
SaHuTOrEPoL

SaHuTOrEPoL or (Statically Hungarian Typed Object Oriented Esoteric Programing Language, pronounced with a rolled r, often shortened to sah) has been made by User:MinekPo1 to be annoying to write code in.
== Overview ==
=== Variables ===
Variables in SaHuTOrEPoL can have between three and eight characters, exactly two of which have to be underscores the rest being either lower-case or upper-case letters.
The first letter in a variable name declares its type.
For example the variable i__a is of type i (which is an integer).
=== Basic syntax ===
Line comments start with two dollar signs.
 $$this is a comment
 $$this is also a comment
All instructions must be followed by "do".
The instructions are
* variable declaration (${varname} do)
* variable assignment ({variable}${expression} do)
* function declaration (${varname}({arguments separated by commas}) {body} do)
* type definition ({type}${body} do)
* import statement (${var or typename}${library} do)
Category:2021 Category:Unknown computational class Category:Implemented Category:Object-oriented paradigm
Sadako

Sadako was inspired by origami folding and uses a paper square with side lengths of 1 as storage. Each line starts with | ​ and is numbered top to bottom, where the first line is line 0. Commands on the same line are separated by : .
== Commands ==
 A -> B | Fold point A towards the user to point B
 A => B | Fold point A away from the user to point B
 ~ | Undo last fold
 = V A B L | If the distance between points A and B equals V, jump to line L
 > V A B L | Same as = but greater than V
 < V A B L | Same as = but less than V
 ? | Take 1 bit of input. If it equals 0, skip the next command
 ! A B | Multiply the distance between points A and B by 1000, truncate it, and print it as an ASCII character
 . A B | Print the distance between points A and B
 [ | Comment (goes to end of line)
== Paper folding ==
Initially, the square is labelled with the points:
 A B
 .-----.
 | |
 | |
 | |
 | |
 | |
 '-----'
 C D
Whenever a new fold is made, all unlabelled intersections of 2 or more lines or unlabelled corners get labelled with the next unused letter. 
They are labelled from the top, going right, then down.
Any time a point is created, it can't be removed without getting rid of the paper.
Once point Z is created, point names continue with AA, AB, AC... BA, etc.
Example:
 | A -> C : ~
This program creates a paper and folds it in half vertically, then undoes the fold. This generates 2 new points, E and F.
 A B
 .-----.
 | |
 | |
 E| |F
 | |
 | |
 '-----'
 C D
== Example program: Truth-machine ==
 | ? : = 0 A A 2
 | . A B : = 0 A A 1
 | . A A
Category:Languages Category:Unimplemented Category:Thematic Category:Unknown computational class
Safalra

Safalra is the pseudonym of British computer scientist, erstwhile mathematician and occasional philosopher Stephen Morley. He prefers to be known by the pseudonym due to the existence of various other people called Stephen Morley (including a mathematics professor).
Safalra first became interested in esoteric programming languages after reading the INTERCAL entry in The Jargon File. After discovering Georg Kraml's now-defunct database of esoteric programming languages he created the Sansism and MISC languages.
In 2005 Safalra created the Gravity language to show that a language that cannot be simulated on a Turing machine can be proved Turing-complete. The mathematics this entails are complex, and so far the proof has not been forthcoming, although some simple programs have been produced.
Safalra has contributed to the Esolang Wiki as User:Safalra, but not since 2006. He has created proofs of Turing-completeness for a number of languages, and has translated the German specification of the AlPhAbEt language.
Safalra was, in 2005, in the process of writing online interpreters in Javascript for a number of esoteric programming languages. So far he has written interpreters for HQ9 Plus, HQ9 Plus Plus, NIL, Qdeql and Smurf.
==External resources==
* Personal website
Category:People
Sally

Sally is a toy programming language created by Chris Pressey in 2000.
It is described as "upside-down Forth cake", because it resembles a
(statically-typed) variant of Forth that is written in Polish notation
instead of the more usual Reverse Polish notation. Because of this,
program sources resemble those in more conventionally notated functional languages
like Haskell.
Arguments to functions are not named, rather they are identified by positional
keywords $1, $2 etc. like in Bourne shell or Perl.
The author doesn't consider the language to be very distinctly "esoteric" and
is not sure if it should be considered an esoteric programming language or not.
==External resources==
* 
Category:Languages
Category:2000
Category:Implemented
Category:Unknown computational class
Category:Functional paradigm
Salt

Salt (standing for S(m)al(l)t(alk)) is an object-oriented language invented by User:A designed to be very concise. It was influenced by Smalltalk.
==Language overview==
Salt is an object-oriented language that only contains objects and applications. Here is a 'Hello, world' program:
'Hello, world'
As you see here, it is a string object. You can also do applications to the object like this:
1.2+
Here, this takes the integer object(1) and, with another integer object(2), applies addition(+). The whole language falls in place. (It uses postfix because it is easy to implement.)
You may not use spaces in Salt, as a space indicates a one-line comment(and the source code may ONLY contain 1 line of code).
The languag has operator precedence, but I would be glad if anyone converts this notation to an infix version.
Of course, you can insert nops between them:
1.2.+
Nops in Salt concatenate the previous Object object (namely the Object object, which is the father object of all objects in Salt) with the succeeding Object object, therefore evaluating to an expression without itself.
The following contents are postfix and will be modified in the future. Please don't rely on these examples.
For a more complex example, here is a program that checks whether a number is divisible by 2.
i2%['true']Ṭ['false']ḟ
Quotes and brackets are auto-completed. Here, 
i is an input object; when called by itself, it returns the input's value converted to its appropriate type.
 2% modulos the value by 2 in postfix.
 ['true'] Returns 'true'
 Ṭ Postfix application of the integer object to check if it is a C-defined true; i.e. nonzero.
 ['false'] Returns 'false'
 ḟ application of the integer object to check if it is a C-defined false; i.e. zero.
A same-byte answer that demonstrated dependent types:
iẹ«['true']Ṭ['false']ḟ
Explained:
i Is the input
 ẹ the "even number" class (A subclass of integer)
 « a subclass of?
 ['true'] Return true
 Ṭ If that is true
 ['false'] Return false
 ḟ If that is false
==Arrays==
Unlike Smalltalk, you do not have to waste bytecount to specify the length of the array.
x = Ɲ
Changing elements of the array is not done using the = operator; this operator is used only to bind names to objects. In fact, you never modify data structures; instead, you send a message to the object, and it will modify itself. 
x@4
Index the array
x@4←99
Initialize this index as 99.
Note that the object stored in an array is just like any other object, so we can do things like:
(x @ 1) + 1
==Sets==
x = Ṇ
Create a set
x¦5.x¦22.x¦'add'
Toss things into the set(5,22,'add') The period is optional on the end of the line.
Golfed:
x¦5;¦22;¦'add'
The ; operator refers to the previous object.
You want to type ʂ when you are only interested in returning the object itself. E.g.
x + 5; + 5; + 5; + 5; ʂ
Just returns the value of the object x.
You can simply do this too:
xʂ
==External links==
* Implementation
Category:Languages
Category:Implemented
Category:2019
Category:Object-oriented paradigm
SanFran

== Intro ==
SanFran is an esoteric programming language created by S. R. Farmer in 2006. SanFran is made for making programs that act randomly. SanFran can used to simulate a number of things.
== Functions ==
The functions in SanFran are listed on this table.
 date% - tells the date
 time% - tells the time
 pause% - pauses the program
 print% - prints a command
 open% - opens a file
 delete% - deletes a file
 color% - colors the text according to a command
 kaboom% - a library of strange commands
 completewhack% - a library of random commands
== Commands ==
The commands for the date% funtions are:
 reg - states regular date
The commands for the time% funtions are:
 reg - states regular time
 unix - states unix time
The commands for the pause% funtions are:
 wtext - a notifaction stating that the program has stopped appears
 wotext - the program pauses without any text
The commands for the print% funtions are:
 ran - prints a random remark
 pi - prints pi
 1 - prints 1
 2 - prints 2
 3 - prints 3
 4 - prints 4
 5 - prints 5
 6 - prints 6
 7 - prints 7
 8 - prints 8
 9 - prints 9
 0 - prints 0
 a - prints a
 .
 .
 .
 Z - prints Z
 endline - ends the line
Category:Languages
Category:2006
Category:Unknown computational class
Category:Usability unknown
Sandbox/td

In Sandbox programming language you can use sand and a shovel to do things
 _ ;This is just sand
 |_ ;This is sand and a shovel
 |q ;This is just a shovel
Also, there is an accumulator
== Instructions ==
_ > Decrements the accumulator
|_ > Increments the accumulator
|q > Prints the accumulator in this order:
::::::::1 - a
::::::::2 - b
::::::::3 - c
::::::::4 - d
::::::::5 - e
::::::::6 - f
::::::::7 - g
::::::::8 - h
::::::::9 - i
::::::::10 - j
::::::::11 - k
::::::::12 - l
::::::::13 - m
::::::::14 - n
::::::::15 - o
::::::::16 - p
::::::::17 - q
::::::::18 - r
::::::::19 - s
::::::::20 - t
::::::::21 - u
::::::::22 - v
::::::::23 - w
::::::::24 - x
::::::::25 - y
::::::::26 - z
::::::::27 - 
::::::::28 - ,
::::::::29 - .
::::::::30 - !
::::::::31 - ?
::::::::32 - ñ
== Examples ==
=== Hello world ===
 |_|_|_|_|_|_|_|_|q
 ___|q
 |_|_|_|_|_|_|_|q|q
 |_|_|_|q
 |_|_|_|_|_|_|_|_|_|_|_|_|q
 ____|q
 ________|q
 |_|_|_|q
 ______|q
 ________|q
== See also ==
* +-
Category:Languages
Sansism

Sansism is an esoteric programming language devised by Safalra (Stephen Morley) in November 2003. It is based on Brainfuck and Befunge. Originally a two-dimensional language, it was later generalised to function in any number of dimensions while still using the same eight instructions. Sansism is Turing Complete.
==Origin of the name==
If you like recursive acronyms, Sansism stands for Safalra Allowed No Swearing In Sansism's Moniker (as opposed to Urban Müller, who did allow swearing in Brainfuck's name). If you don't like recursive acronyms, Sansism is a compound word meaning 'without doctrine' (sans ism).
==Two-dimensional Sansism==
===The memory===
Sansism's memory is two dimensional. A memory pointer is moved through the memory using the ! command. The direction of movement is controlled by the memory director which is rotated anticlockwise using the # command.
===The codespace===
Sansism's codespace is also two dimensional. The program counter moves through the codespace after each command is executed in a direction specified by the program director, which is rotated counter-clockwise by the G command if the current memory cell is non-zero. The > command sets the program director to point right.
===Other commands===
The . , + and - commands behave exactly as they do in Brainfuck.
==Multidimensional Sansism==
Sansism can be extended to multiple dimensions by generalising the rules for the memory director and program director. The precise details can be found in the Multidimensional Sansism specification, under External resources.
==Computational class==
Sansism is Turing Complete, by equivalence to Brainfuck.
==Example programs==
The examples programs can be used with the Sansism Interpreter, found under External resources.
===Hello World===
 G GGG
 >++++++++++>!+++++++!++++++++++!+++!+##!!!!##-G+G
 G.+++++++++++++++##!!##.++!.+++..+++++++.+!.++! G
 G!.+++.------.--------.!+.!.G GG
==External resources==
* 
* 
* 
* 
Category: Languages
Category: 2003
Category: Cell-based
Category: Turing complete
Category: Brainfuck derivatives
Category: Turing tarpits
Category: Two-dimensional languages
Category: Multi-dimensional languages
Category: Implemented
Category: Low-level
Sansism Turing-completeness proof

It can be shown that Sansism is Turing-complete by showing that every program written in Brainfuck (a known Turing-complete language) can be converted into a Sansism program exhibiting the same behaviour. This page outlines the conversion process - for a formal algorithm see the external resource 'Sansism Turing-Completeness Proof'.
The commands + - , and . behave in the same way in the two languages, so no change is necessary.
If MD (memory director) is pointing right, < and > can be converted into ! and ##!## (note that the second conversion maintains the direction of MD).
A loop of the form 'entry[code]exit' can be converted into a Sansism loop of the form:
 G G GG
 >codeG++-G
 entryG > exit
Note that the top line and right section can be moved away in order to create space for further inner loops.
==External resources==
* 
Category:Proofs
Sapphire

Sapphire
Created by user:Shannarra
Sapphire is Ruby's evil twin.
In Sapphire, you write pure Ruby code, but with a twist.
Your code MUST fail to execute. 
If you are unfortunate enough to run a Ruby program in Sapphire that exits properly, you will be SEVERELY punished - one randomly selected file from your computer will be permanently deleted. 
It can be absolutely anything, from a simple file on your desktop to a system file that breaks your computer. 
This means that Sapphire ensures that you write the worst possible code.
Example of good Sapphire code:
puts 'helllo'
raise 'adasd' # <--- Note the `raise`, without it, your program will fail and you will lose a file
FizzBuzz in Sapphire:
 1.upto 100 do |i|
 string = ""
 string += "Fizz" if i % 3 == 0
 string += "Buzz" if i % 5 == 0
 puts "#{i} = #{string}"
end
1/0
Sapphire interpreter
The interpreter was written in Ruby, but could just as easily be written in C or Assembly even.
# frozen_string_literal: true
`ruby #{ARGV[0]}`
unless $?.success?
 puts "ok, I'll allow it...this time"
 return
end
file = Dir.glob('/home/**/*').sample
puts "Deleting your file \"#{file}\"..."
File.delete(file)
puts "Your file \"#{file}\" was permamently deleted. Write worse code next time."
Latest possible version of the Sapphire interpreter can be found at Sapphire.rb
Sashleyfuck

Sashleyfuck is just like Brainfuck, but it uses the letters S, A, H, L, E, and Y, in addition to the conditional constructs [ and ]. It was made after MiroslavRD being the biggest Sashley hater.
__FORCETOC__
== Commands ==
Most of the commands utilize a letter from the term Sashley. Since the word sashley has 2 S's, sahley is used. That means [ and ] can be still used. 
Command	Description
s 	moves the pointer to the right, but it gives you a fake syntax error while it does the command anyway. It was referenced from Sashley's right eye, which is black with a purple X in it.
a 	Moves the pointer to the left.
h 	Increments the memory cell under the pointer.
l 	Decrements the memory cell under the pointer.
e 	Outputs the character signified by the cell at the pointer.
y 	Inputs a character and stores it in the cell at the pointer.
[ 	Jumps past the matching ] if the cell at the pointer is 0.
] 	Jumps back to the matching [ if the cell at the pointer is nonzero.
== "Hello World!" ==
 shhhhhhhh[ahhhhhhhhsl]ahhhhhhhheshhhhh[ahhhhhsl]ahhhhehhhhhhheehhheshhhhhhhhh[alllllllllsl]ahheshhhhhhh[ahhhhhhhsl]ahhhhhheshhhhh[ahhhhhsl]alehhhellllllelllllllleshhhhhhhh[allllllllsl]alllele
=== Output ===
 Syntax error - JUST KIDDING: Hello World!
== Cat program ==
The infinite cat program amounts to:
 ye[ye]
==Implementation==
A very simple interpreter implementation in Common Lisp constitutes the following:
 (defun interpret-Sashleyfuck (code &aux (position 0))
 "Interprets the Sashleyfuck CODE and returns NIL."
 (declare (type string code) (type fixnum position))
 (symbol-macrolet ((character (the character (char code position))))
 (let ((pointer 0)
 (memory (make-hash-table :test #'eql))
 (error-printed-p NIL))
 (declare (type integer pointer) (type hash-table memory) (type boolean error-printed-p))
 (loop while (< position (length code)) do
 (case character
 (#\s (incf pointer)
 (unless error-printed-p
 (format T "Syntax error - JUST KIDDING: ")
 (setf error-printed-p T)))
 (#\a (decf pointer))
 (#\h (incf (gethash pointer memory 0)))
 (#\l (decf (gethash pointer memory 0)))
 (#\e (write-char (code-char (gethash pointer memory 0))))
 (#\y (format T "~&Please input a character: ")
 (setf (gethash pointer memory)
 (prog1 (char-code (read-char))
 (clear-input))))
 (#\[ (when (zerop (gethash pointer memory 0))
 (loop with level of-type fixnum = 0 do
 (incf position)
 (when (>= position (length code))
 (error "No matching ']' found."))
 (case character
 (#\[ (incf level))
 (#\] (if (zerop level)
 (loop-finish)
 (decf level)))
 (otherwise NIL)))))
 (#\] (unless (zerop (gethash pointer memory 0))
 (loop with level of-type fixnum = 0 do
 (decf position)
 (when (minusp position)
 (error "No matching '[' found."))
 (case character
 (#\] (incf level))
 (#\[ (if (zerop level)
 (loop-finish)
 (decf level)))
 (otherwise NIL)))))
 (otherwise NIL))
 (incf position)))))
Category: Languages
Category: 2019
Category: Turing complete
Category: Brainfuck derivatives
Category: Low-level
Category: Stubs