nyuuzyou/wikis huggingface dataset:
Sonata

Sonata is a string-rewriting language by User:Afarnen.
== Language overview ==
All program data is represented as a single string. This string is repeatedly manipulated in a deterministic fashion according to rewriting rules of the form
 lhs->rhs
A single step of computation rewrites the string according to the first applicable rule. If no rule can be applied to the string, the program halts.
Note that the left-hand side of a rule must match the entire string, not just a substring. For example, the rule 
 apple->orange
transforms "apple" into "orange", but not "1apple2" into "1orange2".
There are two types of variables that can appear in a rule, s-vars and m-vars. An s-var stands for any single character and is written by prepending a "^" to any character, while an m-var stands for any substring of zero or more characters and is written by prepending a "_" to any character. For example, the rule
 ^A_B->^A^A_B
duplicates the first character in a string. Here "^A" represents the first character, and "_B" represents the rest of the string.
M-vars are bound to substrings left-to-right, and always match the shortest possible substring so that the left-hand side matches the entire string. For example, the rule
 _Aa_Bb->_A,_B
transforms "aabb" into ",ab" and not "a,b".
A Sonata program is simply zero or more rules written on separate lines. Rules are searched from top to bottom. A program's input is the initial value of the string to be rewritten, and its output is the final value of the string if the program halts.
== Turing completeness ==
Sonata can trivially emulate any m-tag system. Since the set of all m-tag systems (for any m>1) is Turing-complete, Sonata must also be Turing-complete. For example, the program
 a^X_Y->_Ybc
 b^X_Y->_Ya
 c^X_Y->_Yaaa
emulates the 2-tag system
 a -> bc
 b -> a
 c -> aaa
which computes the Collatz sequence for some number n, written in unary using a's.
Category: 2010
Category: Languages
Category: Unimplemented
Category: String-rewriting paradigm
Category: Turing complete
Category: Turing tarpits
Sophie

Sophie (Hebrew for "Finite") is an esoteric programming language created by User:Oshaboy. It is designed to be equivalent to a Finite State Automaton because Finite State Automata are underappreciated. Technically everything in our finite universe is a Finite State Machine
== Overview ==
The language has a single accumulator that can store integers. You cannot add or subtract from the accumulator or store it anywhere. You can only assign it constants and check its value. The accumulator should be unbounded. But anything 16 bits and up should be plenty.
 [] - loop until break
 * - break loop
 . - output accumultor as number
 : - input number to accumulator
 , - output accumulator as char
 ; - input char to accumulator
 @c{}{} - if accumulator is c, do the first {} otherwise do the second {} (second {} optional)
 @$n{}{} - if accumulator is n, do the first {} otherwise do the second {} 
 #c - load char constant c into accumulator 
 #$n - load number constant n into accumulator
 & - halt
Brackets without a condition will never get run. This can be used for comments.
 {This is a comment}
== Computational Class ==
A Finite State machine can be converted to a Sophie script using an infinite loop where the accumulator when it enters the loop determines the state. A big "if elif else" can run code based on the state. 
However it is not Turing Complete because you can solve the halting problem for any given Sophie program. Run the program until it either halts or enters a loop with the same accumulator value (which occurs if and only if it loops forever). It might be a pushdown automaton but I doubt it. 
== Examples ==
Hello World
 #H,#e,#l,,#o,#,,# ,#W,#o,#r,#l,#d,#!,&
Truth Machine
 ;@1{[,]}{,&}
Cat Program
 [;@$0{&}{,}]
Xor Program
 :@$0{:@$0{#0,}{#1,}}{:@$0{#1,}{#0,}}&
== External Links ==
* Reference Implementation by User:Oshaboy.
* Python interpreter by User:Bangyen.
Category:Languages
Category:Implemented
Category:Finite_state_automata
Category:2021
Category:Low-level
Sorry

Sorry is a esolang created by User:Yayimhere. its Underload but with one change that makes Sorry have only two commands
== information ==
there is one change. now the ^ does dis:
:pop top 4 elements. the first popped is a second popped is b, third popped is c, and last popped is d. now add d in after the command, length of a, times, each time with c prepended and b appended
also the subset is only []^(() is []). and yes this is still Turing-complete since : can be simulated:
 [[][]][**]^
to do normal ^:
 [ ][ ][*]^
also yes a space is interpreted as nothing. this was added because the content of [] is always of at least length 1(which is how [[] is possible). so to push nothing:
 [ ]
if you try to run a command with unmatched brackets the program gives an error
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Stack-based
Category:Low-level
Soul

Soul is an esoteric concatenative one-stack language, a 
small explorative language with an interpreter written in
a day.
Most concatenative languages work on a state, often that's
another stack. For example, Forth has a data and return stack
and Postscript has an extra stack outputting to a page.
Soul is a minimalist language that provides one thing, and
one thing only, the one sole stack. That, of course, is
very problematic as a model of computation but Soul gets
around that with two tricks:
1. Treat the stack as random access memory.
2. Whenever a constant integer or text is found on top of the stack, 
that gets swapped with whatever is underneath.
Soul expressions consist of integers, texts, and words. Words may define other 
expressions. A Soul expression defines a stack. The top of the stack is 
repeatedly evaluated until the stack is empty.
==Predefined Operators==
fetch, put, and delete inspect or modify the stack, they all
take an integer argument where put takes a second argument to put somewhere
in the stack.
The arithmetic operators +, -, *, / are all binary prefix
operators. + is overloaded to work on texts also.
The equality operator = tests two arguments for equivalence, it
results in either true or false. Both booleans are functions
that select between two arguments; e.g., true f g evaluates to
f.
print and line are the basic input/output words. to_int and
to_text convert between integers and texts.
==Examples==
Hello World example:
 "hello" print "world" print
Output 42, showcasing the defintion of a word:
 # calculate the answer to everything
 :f * 6
 + 3 4 f print
The faculty function:
 # the faculty function
 
 # get
 :get2 delete 1
 :get1 fetch 5 + 3 delete get2
 :get0 fetch 4 + 4 fetch get2 
 :get fetch 2 get0 get1 
 
 # fac
 :fac3 get 2 fac *
 :fac2 fetch 3 - 1 fac3
 :fac1 delete 1 1
 :fac0 get 4 = 0 fac1 fac2
 :fac fetch 1 fac0 
 
 fac 6 print
The Soul interpreter is written as an Egel script and implements a REPL.
== External links ==
* Interpreter source code
Category:2022 Category:Turing complete Category:Implemented Category:Stack-based
SovietCode

SovietCode is a Python-interpreted, joke programming language created by User:Vulture001. The sole purpose of the language is to print a string in a text file.
==Code examples==
===Hello, World program===
 "In Soviet Russia,"
 "'Teddy Bear'" prints YOU!!!
==Interpreter==
 import random
 import re
 f = open("sr.txt", "r")
 fr = f.read()
 cq = fr.count("'")
 tf = "In Soviet Russia," in fr
 if tf == True:
 print('In Soviet Russia,')
 qlist = re.findall("\'(.*?)\'",fr)
 print(qlist[0] + " prints YOU!!!")
==External resources==
* Interpreter on Github
Category:Languages
Category:2020
Category:Implemented
Category:Output only
Category:Total
Category:Joke languages
Category:Thematic
Category:Unusable for programming
Spacebar

Spacebar is an esoteric variant of JavaScript. The Spacebar interpreter first takes your code and adds spaces in random locations. Then it interprets your code as JavaScript. More specifically, by random we mean that for each character in your code there is a 50% chance that a space will be inserted before it. This action is determined independently for each character.
==Examples==
===Hello, World!===
This program prints out the words Hello World!:
 F = ![]
 T = !![]
 U = []
 d = (U+[])[2]
 e = (T+[])[3]
 f = (F+[])[0]
 i = (U+[])[5]
 l = (F+[])[2]
 n = (U+[])[1]
 r = (T+[])[1]
 s = (F+[])[3]
 t = (T+[])[0]
 u = (U+[])[0]
 L = f+i+n+d
 c = ([][L]+[])[3]
 j = ([]+[][e+n+t+r+i+e+s]())[3]
 o = ([T]+[][L])[1+[0]]
 C = c+o+n+s+t+r+u+c+t+o+r
 X = (U+[])[1]+(F+[])[1]+([]+(+[])[C])[1+[1]]+(T+[])[3] 
 Y = (T+[])[0]+([T]+[][L])[1+[0]]+([]+[])[C][X] 
 p = (+(2+[1]+[1]))[Y](3+[1])[1]
 S = s+p+l+i+t 
 J = j+o+i+n ;
 [][L][C]( "console.log('Hello"[S](" "[0])[J]([]) + " "[0] + "World!')"[S](" "[0])[J]([]) )()
This Hello World! example borrows significantly from work done to make a JSFuck encoder. As in JSFuck, find and constructor are used to simulate eval. split and join are used to remove any spaces from a string. Recall that the interpreter may or may not insert random spaces in the string.
==Interpreter==
Written in JavaScript.
function spacebar(program)
{
 let result = "";
 for(const char of program)
 {
 if(Math.random() < 0.5) result += " ";
 result += char;
 }
 eval(result);
}
== See also ==
* Spaced, a variant where all characters have space inserted between them
Category:Languages Category:Esoteric subset Category:Turing complete Category:Implemented
Spaced

Spaced is an esoteric subset of JavaScript. Let s be the code interleaved with spaces, and define f:
 f = (...a) => { let [$, _] = a; return eval(s) }
Then the function f is called with the command line arguments, and the return value is outputted.
== Example programs ==
=== Hello, world! ===
 (q="Helo, Wrd!")[1]+q[3]+q[5]+q[5]+q[7]+q[9]+q[9+2]+q[9+4]+q[7]+q[9+6]+q[5]+q[9+8]+q[9+9+1]
== Implementation ==
* https://github.com/ConorOBrien-Foxx/spaced
== See also ==
* Spacebar
Category:Languages Category:Esoteric_subset Category:Turing complete Category:Implemented
Spacefish

== Spacefish ==
Note: This is merely an idea. Nothing concrete has been worked out yet.
Spacefish is based on a 2-dimensional storage grid. Initially there's only one storage cell available but through use of that initial cell
one can "expand space" to get more storage cells. 
=== Storage ===
Once a storage cell contains an active value it expands the space in all 8 directions by log2 of the active cell's value. However, every active cell
distorts the values in other cells (halfed for every cell). 
* Are active cells
Numbers indicate how much is added to a cell if it were active. 
0 -> put 8 in it
22222
24442
24*42 * = 8. Surrounding Cells are distorted (log2)
24442
22222
So, if you happen to place 1 into the upper left Corner you get
111
1*3222 * = 1 + 2 = 3
135442
 24*42 * = 8
 24442
 22222
=== Instructions ===
Instruction Description
> Move to the cell to the left
< Move to the cell to the right
^ Move to the cell above
v Move to the cell below
+ Increment value in the current cell
- Decrement value in the current cell
* Multiply value in the current cell by two
/ Divide value in the current cell by two
[ ... ] Loop: While current cell value is not zero
I Read character from stdin
O Write character to stdout
( ... ) If: If current cell value is zero
{ ... } If: If current cell value is not zero
A cell is 8bit (Values 0 .. 255). If a value would reach 256 (or bigger) it wraps around. If you would move to a non existing cell it also wraps around.
=== Computational Class ===
Yet unknown. Storage can be expanded by placing values in it so it should be possible to achieve "infinite memory". I'm just not sure if
one can achieve an arbitrary effect at an arbitrary point. 
== Spacefish 1D ==
Spacefish 1D is going to be a version of Spacefish with only 1D Storage.
Incomplete code to demonstrate "distortion" (Python):
import math
space = [0]*11
j = 0
while j < 11:
 space[j] = [0,0]
 j += 1
prog = "++++>++>>+"
p = 0
ptr = 5
while p < len(prog):
 c = prog[p]
 # Instruction handling
 if(c == '+'):
 space[ptr][0] += 1
 j = 0
 while j < len(space):
 space[j][1] = 0
 j += 1
 j = 0
 while j < len(space):
 i = space[j][0] / 2
 d = 1
 while i >= 1:
 space[j + d][1] += i
 space[j - d][1] += i
 d += 1
 i /= 2
 j += 1
 elif(c == '>'):
 ptr += 1
 ptr %= 10
 while( (ptr != 5) and (space[ptr][1] == 0)):
 ptr += 1
 ptr %= 10
 
 print space
 p += 1
print map(sum,space)
Category:Unknown_computational_class
Spaces and tabs

Spaces and tabs is an esoterical programming language made of, you guessed it, spaces and tabs.
==Commands==
Spaces and tabs on one side, BF on the other.
Spaces and tabs 	BF
[SPACE][SPACE][SPACE]	>
[SPACE][TAB][SPACE] 	<
[TAB][SPACE][SPACE] 	
[TAB][SPACE][TAB] 	
[TAB][TAB][SPACE] 	.
[TAB][TAB][TAB] 	,
[SPACE][SPACE][TAB] 	[
[SPACE][TAB][TAB] 	]
end 	EOF
==Examples==
===Cat===
 	 						 		end
===Hello, World!===
This program prints the message “Hello, World!” to the standard output:
 	 		 	 	 	 	 	 	 	 		 	 	 	 	 		 		 	 	 	 	 	 	 	 	 	 	 		 		 	 	 	 		 			 	 	 	 	 	 	 	 		 	 	 	 			 		 	 	 		 	 	 		 		 		 	 	 	 		 	 	 	 		 		 	 			 	 	 	 	 		 end
===Truth-machine===
A truth-machine is maintained by this program:
 					 	 		 	 	 	 	 	 		 	 	 		 	 	 	 	 	 	 		 			 		end
==Interpreter==
* Common Lisp implementation of the Spaces and tabs programming language.
Category:Brainfuck derivativesCategory:2023Category:LanguagesCategory:Implemented
Spaghetti

Spaghetti, created by Jeffry Johnston in 2001, is "designed to produce spaghetti code, to the point where every program line can be arranged pretty much randomly and the program should still function properly."
==Computational class==
A mapping from BASIC (or C) to Spaghetti is given in the specification, so there is little doubt that Spaghetti has adequate control structures. However, a Spaghetti program can access a maximum of 4.11 × 1062 bytes. Large as this is, it's still finite, making Spaghetti a bounded-storage machine with unbounded input.
==See also==
* Linguine, a Spaghetti derivative
==External resources==
* 
Category:Languages
Category:Finite state automata
Category:Implemented
Category:2001
Spam

Spam is an esolang invented by User:None1. Its programs are to imitate a kind of spam in text massages that wastes time for people who see it by letting you eyes move between lines and ending up saying that you are fooled.
==Syntax==
Every program consists of lines like this:
 <first clause>, <second clause>.
The space after the , is mandatory and programs are case sensitive.
There are two cases, one case is that the first clause is I just want to say and the second clause is you are fooled, in this case, the program terminates when reaching the line. Otherwise the first clause is a command and the second clause is a jump.
Unlike normal languages, a 'jumpin a line in a Spam program tells you which line to execute next, a jump is like this:
 please read line value
value can be an integer or a variable. The line (value-1)%n+1 (n is the total number of lines) is jumped in case that the value is less than 1 or more than n.
There are these commands, variables store unbounded signed integers, when attempting to read a non-existent variable, a variable with value 0 is created (uppercase letters stand for variables and i1, i2, i3... stands for integers, v1, v2, v3... stands for integers or variables):
 Command - Meaning
 I want to tell you a secret - Where to start the program, there must be exactly one of this command in a program (but it doesn't need to be in the first line)
 Add A by v1 - Explains itself
 Subtract A by v1 - Explains itself
 Multiply A by v1 - Explains itself
 Set A to v1 - Explains itself
 Say v1 - Print v1 as integer
 Speak v1 - Print v1%65536 as Unicode character
 Hear A - Input A as integer
 Listen A - Input A as Unicode character
 Mess up A - Make A a random integer from 0~A-1 if A is positive, and 1-A~0 if negative, and 0 if zero
 Print "string" - Prints string
EOF returns 0.
==Examples==
===Hello, World!===
 I want to tell you a secret, please read line 2.
 Print "Hello, World!", please read line 3.
 I just want to say, you are fooled.
===Cat Program===
 I want to tell you a secret, please read line 2.
 Listen a, please read line 3.
 Speak a, please read line 2.
===A+B Problem===
 Hear a, please read line 4.
 I want to tell you a secret, please read line 1.
 I just want to say, you are fooled.
 Hear b, please read line 6.
 Say a, please read line 3.
 Add a by b, please read line 5.
===Truth Machine===
 I want to tell you a secret, please read line 2.
 Hear a, please read line 3.
 Add a by 4, please read line 5.
 I just want to say, you are fooled.
 Say a, please read line a.
Category:Languages
Category:2024
Category:Pseudonatural
Category:Unimplemented
Category:Unknown computational class
Spare Change

Spare Change is an esolang inspired by the Money Pieces, by Math Learning Center app on the App Store.
== The Commands ==
This esolang has four registers: the Left Hand (≤), the Right Hand (≥), the Pocket (¢), and the Bank
($).
Each one can be modified by using any of the commands below:
* n>r - Move n dollars into the register, adding onto what is already there.
* r>n - Take n dollars from the register.
* r1>r2 - Move the money in register 1 into register 2, adding onto what is already there.
* r1=r2 - Swap the contents of register 1 with register 2.
* r=n - Set the register to n.
* r1+r2>r3 - Add register 1 and 2 together, and store the result into register 3.
* r1-r2>r3 - Subtract register 2 from register 1, and store the result into register 3.
* □>r - Take 1 ASCII character of user input and put it into the register as a number.
* r>□ - Print the register's number as an ASCII character.
* r1(<=>/)r2>n - Jump to the nth instruction if register 1 is less than (<), equal to (=), greater than (>), or not equal to (/) register 2
* r(<=>/)m>n - Jump to the nth instruction if the register is less than (<), equal to (=), greater than (>), or not equal to (/) m
* >>n - Jump to the nth instruction
* //“string” - Comment
=Example Programs=
===Hello, world!===
 //"Hello"
 72>$
 $>□
 29>$
 $>□
 7>$
 $>□
 $>□
 3>$
 $>□
 //"Space"
 $=32
 $>□
 //"World"
 $=119
 $>□
 $>8
 $>□
 3>$
 $>□
 $>6
 $>□
 $>8
 $>□
 //"!"
 $=33
 $>□
Category:Thematic
Category:Languages
Spectr

Spectr is an esoteric programming language where programs are written in a "canvas" of colors. Each color represents a different command or action, which the interpreter processes to perform operations such as arithmetic, loops, and conditional moves.
Spectr was created by Spectral
Spectr operates on a two-dimensional grid (or canvas) where each cell is represented by a specific color code. The interpreter reads each color sequentially from the top left to the bottom right, executing commands based on the color encountered.
Below is a list of commands represented by their respective colors:
Red (#FF0000): Increment the current value by 1.
Blue (#0000FF): Start a loop. The number of iterations is determined by the current value when the loop starts.
Green (#00FF00): Conditional move. If the current value is less than or equal to 0, skip the next move.
White (#FFFFFF): Print the accumulated string and reset it.
As you can tell, the language isnt fully fleshed out, or even really fleshed out. I just wanted to get to the point where you can print hello world because I write the interpreter as I decide how you do things in the language
String Accumulation Commands: The following colors correspond to specific characters that are added to an output string:
#FFA500: H
#A52A2A: e
#8A2BE2: l
#6495ED: o
#D2691E: (space)
#FF7F50: W
#5F9EA0: r
#556B2F: d
Hello World in Spectr
Probably looks something like this:
#FFA500 #A52A2A #8A2BE2 #8A2BE2 #6495ED
#D2691E #FF7F50 #6495ED #5F9EA0 #8A2BE2 #556B2F
#FFFFFF
Category:Languages Category:Works-in-Progress
Spellblocks

Spellblocks is an esoteric programming language simiar to Scratch created by User:AdjectiveNounNumber (me!) on January 25, 2025 ET. very WIP
 Blocks
Block Name 	Description 	Scratch Representation
when start 	Activates when the program starts.	
define [object, variable] 'varname'	Defines an object or variable. 	
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Spellcaster

Spellcaster is an turning tarpit based on casting spells made by Maikeru51. It reads a field of magic nodes, which is given through .png format. The nodes are as following:
*Fire (Red) nodes turn the IP right 90°
*Light (White) nodes turn the current wheel left/right if going left/right, and cycles through the wheels if going up/down.
*Electric (Yellow) nodes execute the command associated with the current wheel's rotation. If the wheel is facing up, the data cell is increased. If the wheel is facing down, the data cell is decreased. If the wheel is facing left, the cell pointer moves left. If the wheel is facing right, the cell pointer moves right.
*Life (Green) nodes cause the pointer not to execute any commands beside Water if the current wheel's rotation is upwards (Zero).
*Water (Blue) nodes cause the pointer to go back until reaching a Life node if the current wheel's rotation isn't upwards (Non-Zero). Else, stop skipping commands (If skipping any)
*Dark (Purple) nodes turn the wheel to face the direction the IP is traveling.
==Colors?==
Spellcaster interprets the color by using revolutionary tactics called comparing RGB values to 128.
*Red = R ≥ 128, B < 128, G < 128. 
*White = R < 128, B < 128, G < 128.
*Yellow = R ≥ 128, B < 128, G ≥ 128.
*Green = R < 128, B < 128, G ≥ 128. 
*Blue = R < 128, B ≥ 128, G < 128.
*Purple = R ≥ 128, B ≥ 128, G < 128. 
==Turing Complete==
Life and Water nodes act exactly like brainfuck's [ and ] respectively. Additionally, Electric nodes can act like brainfuck's + - < or > depending on the direction of the current wheel. Because of this, any brainfuck program without IO functionality can be translated to a Spellcaster program. Since brainfuck is Turing Comeplete without IO functionality, Spellcaster is Turing Comeplete.
Category:LanguagesCategory:Non-textualCategory:Turning tarpitsCategory:No IOCategory:Two-dimensional languages