nyuuzyou/wikis huggingface dataset:
Spice

== Summary ==
A programming language for 'Golfing' in an assembly-like/lite environment.
- Spice is an interpreted assembly-like language with a handful of operators: ADD, `SUB`, MUL`, `DIV`, `MOD`, `PUT`, `GET`, `SWI`, `BRK`, `ALS`, `OUT`, `LOD`, `SIN`, `COS`, `TAN`, `POW`, `REA`, `CLR`, `LEN`, `NUL`. For full descriptions of each operator see the link to the language README in the resources section
- Spice programs are split into two sections; declaration and instruction, split with an @ character.
- All values are dynamically sized double arrays with the exception of string literals, "Some string", which may be used in OUT statements, but not stored
- The end of instructions is denoted by a user-defined character - the first character of the program
== Example code ==
Hello world:
 ;@
 OUT "Hello World"
Or, doing slightly more useful things:
 ;in;temp;res;@
 OUT "Addition calculator - first no:";
 REA in;
 OUT "second no:";
 REA temp;
 ADD in temp res;
 OUT "= " res;
Example module for sorting a passed array from the standard library (std::sort.spice):
 ;unsorted;unsortedVal;currSorted;outerIterator;innerIterator;unsortedLength;sortedLength;finalSortedIndex;return@
 LEN unsorted unsortedLength;
 NUL initalise outer counter to 0; 
 ADD 0 0 outerIterator;
 NUL ===== START OUTER LOOP =========;
 GET outerIterator unsorted unsortedVal;
 LEN return sortedLength;
 SUB sortedLength 1 finalSortedIndex;
 ADD 0 -1 innerIterator;
 NUL ===== START INNER LOOP =========;
 ADD innerIterator 1 innerIterator;
 NUL deal with over-running end of list;
 SWI finalSortedIndex innerIterator 15;
 NUL otherwise, get the current val, and if it's more than unsorted, insert at innerIterator-1;
 GET innerIterator return currSorted;
 SWI currSorted unsortedVal 8;
 NUL ====== END INNER LOOP ==========;
 PUT innerIterator return unsortedVal;
 ADD outerIterator 1 outerIterator;
 SWI outerIterator unsortedLength 3;
 NUL ===== END OUTER LOOP ===========;
== Interpreters ==
A single Spice interpreter exists. See Resources.
== External resources ==
- Spice interpreter on GitHub
- Language README direct link
Category:Languages
Category:Usability unknown
Category:Output only
Category:Low-level
Category:Implemented
Spider's Square

A program written in Spider's Square describes an abstract spider, represented by a moving point, building a web inside a one by one square. The spider can move along the sides of the square, and may place the start of a thread at any point along them. Once the start of a thread has been placed, the spider may move about normally, but may not start another thread until the current one is ended. The spider may end a thread by attaching the other end to the place it is climbing. If the spider is at the attachment point of a started or completed thread, it may divert its path and move along the thread, and may also attach further webbing across the existing thread. 
The spider may also choose to let go and fall, either catching onto a thread or landing on the bottom of the square. When diverting or falling, the spider may have a requirement as to the angle of the thread relative to the spiders direction, and will ignore threads that do not meet it. In the case of multiple matches, a falling spider will grab the first available, If multiple threads are reached at the same time, and in the case facing multiple paths to divert to while climbing, the spider will choose randomly.
If the spider has started a thread when it falls, the thread will be set at the distance between the start of the thread and the point the spider drops from as it falls. The spiders path will then move along an arc around the thread's starting point if the thread is pulled taunt, affecting what threads it will grab. This arc ends if the spider does not grab a thread or land before reaching the point of the arc directly below the start of the thread, it either lowers to the bottom side of the square or retracts to where it started the thread, and will still be able to grab onto thread as if it was falling during this time.
The program should allow for input in the form of locations where flies may appear, but the only output should be the final state of the web, thus making it essentially input-only. The precision with which the spider, thread, and flies are placed are up to the implementation, though the relative precision of the different objects should be predictable, and the relative size of the spider to the flies should be specified at the start of the program along with the flies' position and number.
Spider Giant

Spider Giant is a Trivial brainfuck substitution created by User:PixelatedStarfish for giggles. It is named for the song Spider by They Might Be Giants and substitutes commands for song lyrics.
==Command Table==
Command	Substitute 	Description
> 	Spider 	Move the pointer to the right
< 	He is our hero! 	Move the pointer to the left
+ 	We love you spider! 	Increment the memory cell at the pointer
- 	Get rid of 	Decrement the memory cell at the pointer
. 	Must stop! 	Output the character signified by the cell at the pointer
, 	Step on Spider! 	Input a character and store it in the cell at the pointer
[ 	I promise not to kill you.	Jump past the matching ] if the cell at the pointer is 0
] 	Oh! 	Jump back to the matching [ if the cell at the pointer is nonzero
Category:Brainfuck equivalents Category:2021 Category:Languages Category:Brainfuck derivatives Category:Unimplemented Category:Turing complete Category:Turing tarpits Category:Low-level Category:Joke languages Category:Cell-based
Spin

Spin is an esoteric programming language made by User:Hohoo. Its syntax resembles BASIC.
== Commands ==
Command 	Description
START TO SPIN 	Starts the program. Before it all code is ignored.
STOP SPINNING 	Stops the program. After that all code is ignored.
MORE SPINNING PLEASE 	Starts a loop.
LESS SPINNING PLEASE 	Ends a loop.
WHAT IF SPINNER 	If
HEY SPINNER DO THAT 	Then
WHAT IF SPINNER SCREWS UP	Else
WHAT IF SPINNER DOES THAT	Else-If
NEW SPINNER 	Declare a variable
SPIN THE SPINNER 	Give a variable a value.
SPIN THIS ALL 	Print text/variable.
FEED THE SPINNER 	Store input to a variable.
== Syntax ==
The syntax is as follows:
 COMMAND! Something.
Only the first letter of a word is significant. Thus
 START TO SPIN!
 SPIN THIS ALL! Something to spin.
 STOP SPINNING!
would result:
 Sts
. means space (or newline if it's the last letter). So
 START TO SPIN!
 SPIN THIS ALL! a super dangerous fire. another singing doodle ferry.
 SPIN THIS ALL! Quickly uickly ickly ckly kly ly y
 SPIN THIS ALL! . eat at tea. It turns.
 STOP SPINNING!
would result:
 asdf asdf
 Quickly eat it
A word about variables.
You can assign a value to a variable in this way:
 SPIN THE SPINNER! Variable. Value.
Variable must have an exclamation mark after the variable name when using SPIN THIS ALL command. So
 START TO SPIN!
 NEW SPINNER! Hey ey yes.
 SPIN THE SPINNER! Hot elefant yuck. OH NO EH.
 SPIN THIS ALL! Hello ew ytterbium!
 SPIN THIS ALL! High end yielding.
 STOP SPINNING!
results:
 1
 Hey
Values from keyboard input (FEED THE SPINNER command) don't need the value specified. If you specify it, it will indeed be ignored.
When assigning an integer/float value to variable, the text must be capitals (and must be an English numeral). Example:
 START TO SPIN!
 NEW SPINNER! Look ook ok k.
 SPIN THE SPINNER! Look ook ok k. Hey ey ey..
 SPIN THIS ALL! Look ook ok k!
 SPIN THE SPINNER! Look ook ok k. TEA WAITS ONE.
 SPIN THIS ALL! Look ook ok k!
 SPIN THE SPINNER! Look ook ok k. TWO WISE OAKS. TINY HARMFUL READABLE EMPLOYEE ERASER.
 STOP SPINNING!
resulting
 Hey.
 2
 2.3
== Examples ==
=== Hello World ===
 START TO SPIN!
 SPIN THIS ALL! High end lock likes offering. With old red lamps dodged.
 STOP SPINNING!
Category:Languages
Category:Unimplemented
Category:2007
SpinGate

= SpinGate =
SpinGate is a 1 bit computer with a corresponding single bit 1-instruction language intended to be implemented in hardware with the minimum number of logic gates. It has only a single 1-bit instruction - 0 or 1
= Demo =
Interactive Demo
GitHub
= SpinGate Machine and Instruction =
A SpinGate machines consists of 
* data register (a shift register) 
* accumulator bit 
* phase bit (load, store) 
* NAND gate
The instruction is as follows
Instruction	Description
0 	rotate shift register
1 	when load - accum <= bit0, phase <= store
 	when store - bit0 <= bit0 NAND accum, phase <= load
= I/O =
SpinGate does not support I/O, however, the begining of a program can be used to set the state of the data register, and the data register can be considered as output at the completion of a program
= JavaScript Implementation =
A SpinGate machine can be implemented in JavaScript as follows:
let cpuData = 0
let cpuBits = 4
let cpuIndex = 0
let cpuStore = false
let cpuAccum = 0
function spin() {
 cpuData = cpuData << 1 | (cpuData >> (cpuBits - 1))
}
function gate() {
 if (cpuStore) {
 cpuData = (cpuData & -2) | !(cpuAccum & (cpuData & 1))
 } else {
 cpuAccum = cpuData & 1
 }
 cpuStore = !cpuStore
}
= Assembly Language =
libspingate is a JavaScript library for constructing SpinGate programs.
== Init ==
declare a SpinGate machine, and set its register size and inital state
init("0000")
== Prog ==
register a SpinGate program
prog(name, code)
prog("spin", "0")
prog("gate", "1")
prog("spin back", "000")
prog("toggle", "11")
prog("nop", "1111")
== Bit ==
define a bit position in the data register, with a label
bit(index, label)
logic0 = bit(0, "0")
regA = bit(1, "A")
regB = bit(2, "B")
out = bit(3, "R")
== Nand ==
Perform a NAND operation on two bits:
nand(src, dst)
prog("Clear A", nand(logic0, regA))
Internally, nand() keeps track of the shift register position and uses the register size defined by init() to rotate bit indexes into place. It is therefore defined as a builtin function, to simplify maintaining programs if the register size is changed.
= Composing Programs =
Further operations can be composed by defining new functions using the nand() gate function as a building block
== Bit Operations ==
toggle = (reg) => nand(reg, reg)
clear = (reg) => nand(logic0, reg)
set = (reg) => nand(logic0, reg) + toggle(reg)
copy = (src, dst) => nand(logic0, dst) + nand(src, dst)
swap = (src, dst) => copy(dst, tmp0) + copy(src, dst) + copy(tmp0, dst)
== Logic Gates ==
and = (dst, src) => nand(dst, src) + toggle(dst)
or = (dst, src) => toggle(dst) + toggle(src) + nand(src, dst) + toggle(src)
nor = (dst, src) => or(dst, src) + toggle(dst)
Category:Languages 
Category:Implemented 
Category:Finite state automata 
Category:No IO
Category:Cell-based
Spite

Spite is a language by User:Nysnamovois based on lisp cells with monadic IO.
 $^fgx = $f$gx
 $`fgx = $$fx$gx
 $.x = x
 $kxy = x
 $$Kxy = x
 $:fghx = if $fx then $gx else $hx
 $?,xy = t
 $?a = f
 $;fgx = ,$fx$gx
 $Mfy = return $fy
 $B,xf = x >>= f
 $b,xy = x >> y
==Examples==
Hello world:
 $^`<.;k:?>^b;^P><`<;< >>^P>.,%h,%e,%l,%l,%o,% ,%w,%o,%r,%l %d
99 Bottles of Beer (almost):
 $`<<.,,:=><k48:=>>k48`<>< >^b;`<>< > `<<;<`<>>< >^b;^b;`<>< >`<>>>< <>>>>`<<;<`<>>< >,^b;:=k48<MkU^P^C<^P^C>,:=>k48;^-;<k1k57;<^-;>k1,^`<.;k:?>^b;^P><`<;< >>^P>.,% ,%b,%o,%t,%t,%l,%e,%s,% ,%o,%f,% ,%b,%e,%e,%r,% ,%o,%n,% ,%t,%h,%e,% ,%w,%a,%l,%l,%,%
 ,57 57
I'm not willing to go much further by hand.
==External resources==
* A terrible Haskell implementation is available here.
Category:Languages Category:Implemented
Splinter

Splinter is an esoteric programming language designed by Keymaker in 2007. It was intended to be Turing-incomplete, and was purposefully kept so, but initially wrongly classified as a finite-state machine, the author not realizing certain things could be done with it, after all. Later, User:ais523 proved it to be a push-down automaton. The language has 26 unbounded memory storages, splinters, but not enough abilities to modify their content. The language has three instructions, one for placing data from splinters to the current program execution, one to set content for splinters, and one for output.
==Example==
Here's an example program to print "1, 2, 3." along with a new-line.
 B{\,\ }
 A{
 \1B
 A{
 \2B
 A{
 \3\.\
 }
 }
 }
 AAA
For more complex example, see a 99 bottles of beer program: http://yiap.nfshost.com/esoteric/splinter/99.spl
==External resources==
* Splinter specs
* Push-down automaton to Splinter compiler
* Other Interpreter
Category: Push-down automata
Category: Low-level 
Category: Languages
Category: Output only
Category: Implemented 
Category: 2007
SplitLang

SplitLang is a programming language that uses splitting, or forking
== Split command ==
 #going to line 2
 split: #wait what, there is another me on line 4
 #ok I guess ill go here, line 3
 split2: #hi other code pointer on line 2
 #i will also go to line 5
== Join command ==
 #ok I will go to line 2
 split: #hi line 3 code pointer
 split2: #hi I am going to line 4
 join split #wait I am merging with the other code pointer
 #ok I am back on line 5 doing normal stuff
== Vars ==
 #ok I'm going to line 2
 a = 10 #ok so I know a is 10
 split: #ok splitting again
 split2: #oh, a is 10
 join split #back to normal
 #yay I still know a is 10, but twice?
== Goto ==
 #Ok everything's normal
 split: #i am splitting, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again, wait I'm here again
 goto 2 #wait I am here, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here again, I am here againn
 split2:
 #infinite code pointers here
Splitreverse

splitreverse is a progrmming language that splits the input into two pieces and reverses the second piece and combines them:
 input: abcd
 output: adcb
more complex:
 input: abcd+hello
 output--: adcb+holle
 output-: adcbholle
 output: aellohbcd
even more complex:
 input: *(abcd)+e
 output---: *(adcb)+e
 output--: abcd+e
 output-: abcde
 output: aedcb
extremely complex:
 input: and=another
 output---: another=and
 output--: arehton=adn
 output-: arehtonadn
 output: andanother
even even even even more complex:
 input: ab\+c
 output---: ac+\b
 output--: ac+b\
 output-: acb\
 output: a\bc
the most complex:
 input: ab#
 output-*infinity: a#b
 output-*infinity-1: aab#b
 output-*infinity-2: aa#bb
 output-*infinity-3: aaab#bb
 ...
hello world:
 input: hdlrow olle
 output: hello world
unary increment:
 input: ^^^+^
 output--: ^^^+^
 output-: ^^^^
 output: ^^^^
hello 2:
 input: *(*(he)+llo)
 output---: *(*(eh)+llo)
 output--: *(he+llo)
 output-: *(holle)
 output: hello
commands:
 abcd -> adcb
 abcd+efgh -> adcb+ehgf -> adcbehgf -> afghebcd
 *(abcd) -> *(adcb) -> abcd
 abcd=efgh -> efgh=abcd -> ehgf=adcb -> ehgfadcb -> ebcdafgh
 \c -> \c (c is a command, \ cancels the command)
 # -> inserts the whole code and runs it, note: last precedence
Category:Languages Category:String-rewriting paradigm Category:Unknown computational class Category:Unusable for programming Category:Unimplemented
Splits

Splits is an esoteric programming language invented by Dr Laurie Tratt in 2024.
== Overview ==
The language uses reverse polish notation and supports literal integers, as well as operators +, -, * and comparison >=.
Every line is either a variable assignment, or a while loop start or end. While loop starts with while condition where condition is an expression evaluating to 1 or 0. While loop ends with keyword end.
== Examples ==
=== Factorial ===
This program computes the factorial of number 5.
 n = 5
 r = 1
 while n 1 >=
 r = r n *
 n = n 1 -
 end
== Implementation ==
Implementation in Python provided by the author.
 import sys
 class Ev:
 def ev(self, s):
 self.vars = {}
 lines = [x for x in s.split("\n") if x.strip() != ""]
 pc = 0
 while pc < len(lines):
 line = lines[pc]
 match line.split(maxsplit=1)[0]:
 case 'while':
 if self.ev_expr(line.split(maxsplit=1)[1]) == 1: pc += 1
 else:
 while lines[pc].split(maxsplit=1)[0] != 'end': pc += 1
 pc += 1
 case 'end':
 while lines[pc].split(maxsplit=1)[0] != 'while': pc -= 1
 case _:
 (name, _, expr) = line.split(maxsplit=2)
 self.vars[name] = self.ev_expr(expr)
 pc += 1
 print(self.vars)
 def ev_expr(self, s):
 toks = s.split()
 stack = []
 for tok in toks:
 if tok.isdigit(): stack.append(int(tok))
 elif tok in self.vars: stack.append(self.vars[tok])
 else:
 rhs = stack.pop()
 lhs = stack.pop()
 if tok == "+": stack.append(lhs + rhs)
 elif tok == "*": stack.append(lhs * rhs)
 elif tok == "-": stack.append(lhs - rhs)
 elif tok == ">=":
 if lhs >= rhs: stack.append(1)
 else: stack.append(0)
 return stack[0]
 Ev().ev(open(sys.argv[1]).read())
Category:Languages
Category:2024
Category:Unknown_computational_class
Category:Implemented
Spoiler:

is an esolang challenge created by User:Ractangle.
==Challenge==
Try to explain the Syntax using this A+B problem code:
 ∅|^ī|^ī+"∅
And this Truth-machine code:
 ∅|^ī?0[0^"∅]?1[1^"<]∅
 
==Syntax==
 Made for the "guess the syntax" kind of game
Command 	Action 	Submitted by
 	Gets user input 	User:RainbowDash
a^ 	pushes a to the stack 	User:RainbowDash
+, -, *, /	Applies the respective operations to the top two elements 	User:RainbowDash
?n[code] 	if the top value on the stack is n then do code. Otherwise skip the true action	User:RainbowDash
" 	prints the top value on the stack 	User:RainbowDash
[ 	Loop points 	User:RainbowDash
< 	Goes to a nearest loop point 	User:RainbowDash
∅ 	Starts the program. Ends the program if encountered again 	User:RainbowDash
 Syntax
Command	Action
ī 	Converts an element in the stack into a interger
£c/ 	Comments. Doesn't execute c
# 	Flip the whole stack.
==Other examples==
===User:XKCD Random Number===
 ∅4^ī"∅
Category:Languages Category:Stack-based Category:Unimplemented Category:2024 Category:Unknown computational class
SpoilerFuck

Fuck is an esolang invented by User:None1 which is a way of displaying brainfuck code with spoilers.
==Syntax==
All syntax are the same, except one: Text wrapped around with brackets in brainfuck are wrapped around with spoilers in Fuck.
For example:
 ++++++++[>++++++++<-]>+.
in brainfuck is
 ++++++++>++++++++<->+.
in Fuck.
==Examples==
This Python program translates brainfuck to Fuck.
print('(code)'.replace("[",'').replace("]",""))
===Cat Program===
 ,.,
===Hello World===
 ++++++++>++++>++>+++>+++>+<<<<->+>+>->>+<<->>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
== See also ==
* 肏你妈的
== Categories ==
Category:Languages
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Turing complete
Category:2023
Spoiler肏

肏你妈的 is brainfuck language based on Fuck and 脑子爆掉.
== Syntax ==
[] replaced with .
More commands: 
 Caption Text
肏你妈的 	Mean
听 	Input a integer and store it.
说 	Output the data as a integer.
跳N 	Jump to Nth character.
A 	Change data to 65.
a 	Change data to 97.
0 	Change data to 48.
滚 	Pop the data out.
空 	Change data to 32.
归 	Change data to 0.
(data) 	Change data to (data).
== Programs ==
=== Hello, world ===
 A上上上上上上上写a上上上上写上上上上上上上写写上上上写(,)写(W)写a上上上上上上上上上上上上上上写上上上写下下下下下下写a上上上写归上上上上右上上上上上上上上左下上写
=== A+B ===
 听右听左上右下左说
== See also ==
Fuck
脑子爆掉
== Categories ==
Category:Languages Category:Low-level Category:2024 Category:Brainfuck derivatives Category:CJK Category:Pseudonatural Category:Turing complete
Spoon

Spoon is a Brainfuck derivative invented by S. Goodwin in 1998. It uses Huffman-coded binary sequences to represent each instruction.
==Command set==
Spoon's command set consists of the commands in Brainfuck, converted to binary sequences through Huffman coding, with two additional commands added on.
Command 	Description
1 	Increment the memory cell under the pointer
000 	Decrement the memory cell under the pointer
010 	Move the pointer to the right
011 	Move the pointer to the left
0011 	Jump back to the matching 00100
00100 	Jump past the matching 0011 if the cell under the pointer is zero
001010 	Output the character signified by the cell at the pointer
0010110 	Input a character and store it at the cell in the pointer
00101110	Output the entire memory array
00101111	Immediately terminate program execution
The language allows other characters to be substituted for 0 and 1, or even for 0 and 1 to be swapped, provided the interpreter is informed. It is therefore possible to make Spoon programs that are also ASCII art.
==Hello world example==
 0101111111110010001111111111010000001101100101001011111110010001111110
 1000000110111001010111111100101000101011100101001011111111111001000110
 0000000000000000001000000110110000010100000000000000000000000000000000
 0000000101001011111111111001000111111101000000110110010100101111110010
 0011111101000000110110010101110010100000000000000000000010100000000000
 0000000000000000101001011111111111001000110000000000000000000100000011
 011000001010
==Interpreter==
As this is a trivial brainfuck substitution an interpreter can be equally trivial.
 #!/usr/bin/ruby
 h = {
 '1' => 'm[p]+=1;',
 '000' => 'm[p]-=1;',
 '010' => 'p+=1;',
 '011' => 'p-=1;',
 '0011' => ')while((m[p]&=255)!=0);',
 '00100' => '(',
 '001010' => 'putc m[p];',
 '0010110' => 'm[p]=STDIN.getbyte if !STDIN.eof;',
 '00101110' => 'print "\n",m,"\n";',
 '00101111' => 'exit;'
 }
 
 r = Regexp.union(Regexp.union(h.keys.sort{|a,b|b.length<=>a.length}),/./);
 eval 'm=Hash.new(p=0);'+ARGF.read.gsub(/[^01]/,).gsub(r,h);
==External resources==
* Spoon website (Wayback machine)
* Spoon on Github
==See also==
* You are Reading the Name of this Esolang
Category:Brainfuck derivatives
Category:Languages
Category:Implemented
Category:Turing complete
Category:Cell-based
Category:Low-level
Category:1998