nyuuzyou/wikis huggingface dataset:
Stasis

Stasis is a pre-Socratic language first produced in the 5th Century BCE, recently revived by User:Rottytooth
==Philosophy==
:We can speak and think only of what exists. And what exists is uncreated and imperishable for it is whole and unchanging and complete. It was not or nor shall be different since it is now, all at once, one and continuous... - Parmenides
* the universe is in constant balance
* there is only one number, its value is zero
* other numbers are illusory, refractions of zero
==Language Overview==
Stasis transpiles to C#, with all primitives replaced with Stasis structs. It could just as well be implemented in JS or really any other procedural syntax. Each time a value is assigned, all other variables are adjusted to keep a collective sum of zero, but maintaining the same ratios. Like Entropy, Stasis has no true ints or chars; behind the scenes, each of these types are represented by a float. In Stasis, an int is the closest whole-number for the current value.
===char===
Chars are a special case in Stasis. Like ints, each is rounded to the closest whole number, then returned as the corresponding Unicode character. However, since there are no negative values in Unicode, every character in the Unicode table is interpreted as its negadecimal equivalent, making half the characters negative.
==Examples==
===Dealing with ints===
 void main()
 {
 	int a = 1;
 	Console.WriteLine(a);
 }
Output:
 0
Since there is no other variable to balance a with, its value remains zero
 void main()
 {
 	int a, b = 5;
 	Console.WriteLine(a);
 }
Output:
 -2.5
===Hello World===
Printing the "Hello, World!" string straight would end up "averaging" all the characters around zero, giving us:
 ????§PX?§???Y
Each character of the Hello World string is adjusted by each that come after. The very first value introduced in the program will go to zero, so we start with a float we will not use again. Then the others are added as Floats, so that after re-calculating, they end up in the correct place:
 void HelloWorld()
 {
 Float j = 0; // a throw-away value that would become zero anyway
 var hw = new String(601, 420.6666666666667, 320.75, 256.6, 216.33333333333333, 128.85714285714286, 101.37499999999999, 139, 147.60000000000002, 136, 119.16666666666666, 103.53846153846153, 33);
 Console.WriteLine(hw);
 Console.WriteLine("\n");
 }
==Implementations==
Partial Implementation in C# (partial indicating it does not force the user to use ONLY Stasis-aware variables)
Category:Languages
Category:Implemented
Category:2011
StateFlip

StateFlip is a 2-D reversible program language, inspired by BackFlip.
There is four commands:
* * toggles the current flipping state. It starts at off.
* / and \ are mirrors. Whether or not they flip when hit is based on the current flipping state.
* | is used to make infinite memory. If hit when moving left, it causes the program pointer to find the next | right of this one in the same row, and start moving left from there, while making everything in between (on the same row) corresponding to the next memory location (all initially start the same as the initial program is written). When hit moving right, it causes the reverse to happen. Hit | moving up or down is nothing.
* Everything else is NOP command, you move straight through.
Normally there is no output. But if you want output, you can make some NOP command to cause output too.
Category:Languages
Category:Low-level
Category:Two-dimensional languages
Category:Unknown computational class
Category:No IO
Category:Reversible computing
Category:2009
Category:Self-modifying
State and Main

State and Main is an esolang by User:PythonshellDebugwindow.
==Syntax==
Programs in State and Main are made up of a main function and a series of state definitions.
===Main function===
The main function can have as much or as little code as you like, and is written like so:
 main
 (code)
 (more code)
 (...)
 (code)
It is executed once, at the beginning of the program, and can't be called again. Main can optionally take an argument (denoted by a lowercase letter):
 main n
 (code)
 (more code)
 (...)
 (code)
This argument is an integer read from STDIN or the command-line args of the implementation.
===State definitions===
Like the main function, a state definition can have as much or as little code as you like, and is written like so where n is the state number:
 state n
 (code)
 (more code)
 (...)
 (code)
If the same state is defined more than once in a program, an error should be raised before execution begins.
===Inside main and state definitions===
Lines of code inside of main and state definitions can be state changes or state returns.
State changes take this form, where n is a number:
 (state n!)
This changes the current state to n. In the main function, if it takes an argument, that argument can be used as well. There's also a special state called H, which halts the program when it's the current state.
State returns take this form:
 (return)
This returns to the previous state (or the main function), e.g. the one which changed the state to the current one. If a state return is reached in the main function, an error is raised.
==Examples==
===Truth-machine===
No output.
 main n
 (state n!)
 state 0
 (state H!)
 state 1
 (state 1!)
Category:Languages Category:2020 Category:Unimplemented Category:Unknown computational class
StatiC

StatiC is a C-like language which is entirely static. It doesn't allocate or deallocate memory.
== Syntax ==
The syntax is like C except you can't use malloc() and free(). You also can't use any standard functions unless you define them yourself, which means you can't use printf().
There are a lot of other things you can't do, all of which involve malloc() and free(). You also can't use pointers.
A lot of this language is hampered by the fact that I don't know C and have never coded in C. Maybe I will end up writing something which isn't valid C code. I don't really care.
== Code Examples ==
=== Integer ===
int main() {
 int f = 5;
 return 0;
}
Category:Languages
Category:2024
Category:Unimplemented
Category:Works-in-Progress
Stax

Not to be confused with the golfing language also called Stax
Stax is a stack based procedural language where instead of having a single stack, you are able to create an infinite amount of your own stacks for whatever data you want.
On my website, cameronsch.com, there is an interpreter and full documentation on how to use the language.
Stax was created by Cameron Schoenecker Cameron (talk) 00:02, 22 August 2020 (UTC)Cameron on 8/17/20 and took 52 hours from idea to finalization to complete. The initial hope being to create a language with a great basis in English making it a great learning tool.
It's worth mentioning however that this hope entirely failed, I still to this day believe Stax is the worst programming language I have ever had the displeasure of using.
== External resources ==
* 
* 
Category:2020
Category:Educational
Category:Implemented
Category:Stack-based
Category:Languages
StegFuck

StegFuck or StegBinaryFuck is a Binaryfuck derivative that encodes binary code in an image using Steganography. Created by User:Oshaboy in 2021.
I don't know if this even makes enough of a new esolang to fit the wiki. But I am uploading it anyway. 
==Overview==
StegFuck images are created by encoding the Binaryfuck program in the image file starting from the top left corner, going right then restarting at the next line from the left. Each channel in each pixel has the least significant 3 bits changed to the binaryfuck command. 
Then the 32bit length of the program is encoded from the bottom right going left and (if the image is thin enough) up in little endian. This results in a similar looking image that encodes the entire program. This is called Steganography. 
Unlike other Image based esolangs like Piet and 4BOD which are visually distinctive. StegFuck images look to the uninitiated just like regular images. Resulting in obfuscation by default. Steganograpy (and by extension StegFuck) works best on noisy detailed pictures with few flat and dark colors, such as photographs. Note that StegFuck programs will not be preserved after lossy compression (such as JPEG compression) or reduction in color space. Images may be compressed automatically when uploaded to some websites and services. So StegFuck programs will be filtered away. 
==Implementations==
oshaboy's python implementation: https://github.com/oshaboy/StegFuck
==See Also==
* Braincopter: A very similar idea
* TernLSB: A very similar idea, but uses ternary LSB's instead of binary ones.
Category:Languages
Category:Turing_tarpits
Category:Brainfuck_equivalents
Category:Non-textual
Category:2021
Category:Steganography
Steganography

Steganography is a techonology for hiding data in media (usually images).
It gives little change to the original media, making the data hidden in it invisible to humans. For instance, this is an image, while this is a StegFuck program as an image almost exactly the same as the previous one, but there is a program hidden in it that humans can't see.
The most common method of this techonology is LSB (Least Significant Bit), that is by assigning the last binary bits in pixels of an image. This method requires the media to be uncompressed or compressed with lossless compression (like PNG images).
==See also==
* Steganography at Wikipedia
* Languages which store their programs using steganography
Category:Concepts
Steps

Steps is an esoteric programming language invented by User:A. Its source is in .mp4 or .wav format.
==Syntax==
As the user try to use this language, the first thing to know is that the user must be strong enough to throw a ball onto steps. (The ball will fall down as being affected by gravity, jumping down more steps as the falling proceeds.)
Then, the commands are scanned by the variable(i.e. the force(which is divided by the mass of the ball).)
The resulting program will be both boring and violent... the user will be damaged badly after a long program.
==Commands demonstrations==
The user should find a step with 13 steps. This demonstration is in textual form, which implies what the user should do while entering the program.
Step 13. #Throw the ball onto the 13th step; it will fall down 1+2+4=7 steps, and 13-7=6. Then, the number will be divided by the mass of the ball(we assume that it is 1g). So, the command 6 will be entered.
==List of commands==
The instruction set is not interesting; it is just a trivial minimalization of Volatile.
6: Push a random number in any range of numbers. The range is determined by what the implementors like.
5: Pop 2 values and push the sum of the 2 values
4: Like +, but subtracts
3: Multiply
2: Divide. 0-division will result in an error.
1: Duplicate the top of the stack
0: Output the top of the stack without popping it
Category:Languages
Category:2019
Category:Unimplemented
Category:Non-textual
Sticks and Stones/Lithomancer

= Lithomancer =
Is a role (processing unit) associated with Sticks and Stones. It is an additional and entirely optional component of the system and will have its own specification for mapping stone triggers (interpretation) to human readable outputs.
Each interpretation rule is defined as follows:
 <trigger>:<output>
Where:
<output> ::= <string-literal> | <output-type> <value>
<output-type> ::= "c" | "i" | "n"
<value> ::= "_" <point> <point> | "!" <point> <point> | "^" <point> <point> <point> | <point> "x" | <point> "y" | <constant>
<point> ::= "A" | "B" | "C" | "*" | "0"
<trigger> ::= <value> | <value> <condition> <value>
<condition> ::= "<" | ">" | "="
* _AB = the distance between edges of A and B
* ^ABC = the angle formed by ABC (in degrees rather than radians)
* Ax = x value of stone A
* Ay = y value of stone A
* !AB = Boolean, whether A and B are touching
* _*B = * wildcard stone, distance between B and any stone
* _0B = 0 origin, distance between origin point and (edge of) B
Value output-types 
*c : character; output <value> as a Unicode code point based on its integer value
*i : integer; output <value> as an integer (truncate rather than round)
*n : number; output <value> as a number to the highest precision possible
<value> can be any linear combination of <values>, e.g.: _AB+_AB+_BC+Bx+48.
== Examples ==
Here is one suggested mechanism for deriving character output from the stones, there are many other ways, some may be better:
Every time B and C are brought together, read the distance between A and B in units as an ASCII (or Unicode) value for "output".
!BC:c_AB
Another less useful example:
^A0B>10.05:"Hello!" = If the angle formed by A0B is greater than 10.05 degrees, output "Hello!"
Stisp/Lisp interpreter

The following is an attempt at implementing Lisp in Stisp. It's completely untested (since, as of August 2022, Stisp hasn't been implemented yet), but it should work with only minor changes.
 # Evaluating things which behave as built-in functions:
 
 (CAR x) -> eval[env] = x -> eval[env] -> car[];
 (CDR x) -> eval[env] = x -> eval[env] -> cdr[];
 (CONS xh xt) -> eval[env] = xh -> eval_cons[xt];
 (EQP x1 x2) -> eval[env] = x1 -> eval_eqp[x2, env];
 (ATOMP x) -> eval[env] = x -> eval[env] -> atomp[];
 (EVAL xx xe) -> eval[env] = xx -> eval_eval[xe, env];
 
 # Evaluating special forms:
 
 (IF cond xt xf) -> eval[env] = cond -> eval[env] -> eval_if[xt, xf, env];
 (LAMBDA params body) -> eval[env] = (CLOSURE params body env);
 (QUOTE x) -> eval[env] = x;
 (LIST . xs) -> eval[env] = xs -> eval_each[env];
 (ENV) -> eval[env] = env;
 
 # Evaluating applications and variables:
 
 (xf . xa) -> eval[env] = xf -> eval_apply[xa, env];
 var -> eval[((var value) . envt)] = value;
 var -> eval[(envh . envt)] = var -> eval[envt];
 
 # Implementations of built-in functions:
 
 (h . t) -> car[] = h;
 (h . t) -> cdr[] = t;
 
 xh -> eval_cons[xt] = xh -> eval[env] -> eval_cons_2[xt];
 h -> eval_cons_2[xt] = xt -> eval[env] -> swapped_cons[h];
 
 t -> swapped_cons[h] = (h . t);
 
 x1 -> eval_eqp[x2, env] = x1 -> eval[env] -> eval_eqp_2[x2, env];
 v1 -> eval_eqp_2[x2, env] = x2 -> eval[env] -> eqp[v1];
 
 v -> eqp[v] = TRUE;
 v1 -> eqp[v2] = FALSE;
 
 (h . t) -> atomp[] = FALSE;
 v -> atomp[] = TRUE;
 
 xx -> eval_eval[xe, env] = xx -> eval[env] -> eval_env_2[xe, env];
 x -> eval_env_2[xe, env] = xe -> eval[env] -> eval_env_3[x];
 e -> eval_env_3[x] = x -> eval[e];
 
 # Implementation of IF:
 
 FALSE -> eval_if[xt, xf, env] = xf -> eval[env];
 v -> eval_if[xt, xf, env] = xt -> eval[env];
 
 # Implementation of application:
 
 xf -> eval_apply[xargs, env] = xf -> eval[env] -> eval_apply_2[xargs, env];
 f -> eval_apply_2[xargs, env] = xargs -> eval_each[env] -> swapped_apply[f];
 
 args -> swapped_apply[(CLOSURE params body env)] = params -> zip[args] -> append[env] -> swapped_eval[body];
 
 env -> swapped_eval[x] = x -> eval[env];
 
 # eval_each:
 
 xs -> eval_each[env] = xs -> eval_each_2[(), env];
 (xh . xt) -> eval_each_2[vs, env] = xh -> eval[env] -> eval_each_3[xt, vs, env];
 () -> eval_each_2[vs, env] = vs -> reverse[];
 vh -> eval_each_3[xt, vs, env] = xt -> eval_each_2[(vh . vs), env];
 
 # Utility functions for lists:
 
 vs1 -> zip[vs2] = vs1 -> zip_2[vs2, ()];
 (h1 . t1) -> zip_2[(h2 . t2), vs] = t1 -> zip_2[t2, ((h1 h2) . vs)];
 () -> zip_2[(), vs] = vs -> reverse[];
 
 vs1 -> append[vs2] = vs1 -> reverse[] -> reverse_and_append[vs2];
 
 (h . t) -> reverse_and_append[vs] = t -> reverse_and_append[(h . vs)];
 () -> reverse_and_append[vs] = vs;
 
 vs -> reverse[] = vs -> reverse_2[()];
 (h . t) -> reverse[vs] = t -> reverse[(h . vs)];
 () -> reverse[vs] = vs;
Category:Implementations Category:Examples
Stoned-Go

Category:LanguagesCategory:2019
Stoned-Go is a esoteric program language involving Go stones on a infinite grid, which is initially empty. In addition to the grid is also a direction flag, which is either horizontal or vertical (initially horizontal). Each stone, in addition to white or black, also has a trigger program associated with it, which is executed when the stone is captured. If multiple stones are captured simultaneously, they are triggered in order left to right starting at the top line, and then next line left to right, etc.
Rules for repeating positions in Go do not apply here; only rules for capturing Go stones are applicable.
The program consists of two lists of commands with | in between; the first part is initialization part and second is looping part.
Comments are allowed; they start with # and last until end of the line. White spaces are also allows except middle of numbers.
The valid commands are:
* Put - or + followed by a number to move the cursor that many spaces in the current direction, and then flip the direction flag. (Equivalently, all stones are moved instead of moving the cursor; the result is the same either way)
* Put / to flip the direction flag without moving the cursor.
* Put [] with zero or more commands in between to place a black stone with the specified trigger program. Does nothing if there is already a stone there.
* Put () with zero or more commands in between to place a white stone with the specified trigger program. Does nothing if there is already a stone there.
* Put ? to halt the entire program if there is a stone here.
Adding a stone may capture others stones and if so, their trigger programs are executed before continuing; however, all captured stones are removed before any trigger programs are executed due to the captures, and are remembered even if new stones are placed in the same position by the trigger programs.
Macros:
* Write {name:tokens} to define a macro, with "name" replaced by the name of macro (anything except spaces and #<>{}: is allowed), and "tokens" with the tokens of the macros. You cannot define a macro inside of another macro, but you can call other macros inside of another macro, as long as the call is not recursive.
* Write ! in a macro definition to put the argument of the macro in its place (it can be used any number of times).
* Write <name:argument> or <name> to call a macro. If the argument is omitted then an empty argument is used.
==Variants==
Inner loop variant: This variant permits | inside of a [] or () block. In that case, that block is itself a program (with the initial configuration of stones when the program is entered and when it terminates will leave the stones for the caller), and if it contains | then ? terminates the subprogram it appears in; if the subprogram has already ended then it is an error. ("Subprogram" only means a block containing a loop, although it is acceptable for the loop to be empty or simply unconditionally terminate.)
Stop

Stop is an esoteric programming language invented by User:A.
,	inputs the register.
:	starts a do...while with register==1, printing the register while the condition is true.
==Example==
===Truth-machine===
 ,:
==Python interpreter==
 def stop(code):
 reg = 0
 for i, c in enumerate(code):
 if c == ",":
 try:
 reg = int(input("> "))
 except ValueError:
 reg = 0
 elif c == ":":
 while True:
 print(reg)
 if reg != 1:
 break
Category:Languages
Category:2018
Category:Implemented
Category:Unusable for programming
Stoplight

Stoplight is a 2-character language. All it does is prints letters.
Character	Action
% 	Increase cell
# 	Print cell value as ASCII value and set cell to 0
It is a joke since it has no purpose and is really inefficient.
===Example===
Print ABC:
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%#
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%#
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%#
Print Hi:
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%#
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%#
Print 0:
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%#
==Interpreter==
Written in NodeJS. Probably a transpiler too.
 function Stoplight(x){eval(x.replace(/[^%#]/g,"").replace(/(.)/g,"$1;").replace(/%/g,"++x").replace(/#/g,`OUTP`+"(String.fromCharCode((y=x,x=0,y)))").replace(/^/,"let y=x=0,OUTP=process.stdout.write;"));}
Category:Joke languages
Category:Total
Category:Unusable for programming
Category:Output only
Category:Implemented
Category: Languages
Stopnotstop

== ATTENTION 'STOPNOTSTOP' IS LITERALLY THE WORST LANGUAGE EVER CREATED, DO NOT IMPLEMENT!!! ==
I will tell you few things about it.
First whatever instructions you put in it, STOPNOTSTOP with literally put into reverse, so like 'STOP' is 'POTS' but then 'GO' etc.. (always put in uppercase)
Here is hello world
 POTS
 TNIRP ENIL DLROW OLLEH
 TRATS
OUTPUT: "HELLO WORLD"
Here is math (42)
 POTS
 YLTINIFNI TNIRP ENIL (((1 + 1) * 12) * 2) / 1
 TRATS
OUTPUT: "42"
Category:Languages
Stopwatch

Stopwatch is a language invented by User:GDavid.
== Program structure ==
A Stopwatch program consists of function declarations, global variable assignments and global variable declarations.
The Main function is called on start.
== Functions ==
Function declarations are of the form
 name(argument1, argument2, ...) {
 body
 }
(shorthand for assigning a lambda to name)
Lambda functions can be created with
 (argument1, argument2, ...) {
 body
 }
A function can be called with
 name(argument1, argument2, ...)
Recursion is not allowed.
== Variables ==
Variables can be assigned (only once) with
 name = value
Variables are implicitly declared in function scope. To declare a variable in the scope of the enclosing block, use
 var name
Name collisions inside functions are not allowed.
== Values ==
Number constants can be used in the code, but no arithmetic operators are available.
A stopwatch can be created (but not started) using watch.
A stopwatch can be started/resumed using start watch and paused using stop watch.
A stopwatch can fire a split event with split watch.
Start, stop, split and time watch return the current time of the watch.
Functions are values.
== Flow control ==
You can wait N seconds using
 sleep N
(N is the return value of sleep)
Multiple instructions can be executed in parallel with
 parallel {
 instruction1
 instruction2
 ...
 }
The parallel block finishes when all instructions inside finish.
Sequential execution (useful in parallel)
 do { ... }
Infinite loop
 repeat { ... }
Repeat until N splits reached on a stopwatch
 forsplits (stopwatch, N) { ... }
Break out of loop
 break
Continue looping with next iteration
 continue
Return from a function early
 return value
0 is returned when control reaches end of function.
== I/O ==
Wait for a keypress
 wait in
Output a character
 out char_code
Any unicode character should be accepted. Invalid codes don't do anything.
== Examples ==
 // add two numbers
 add(a, b) {
 w = watch
 start w
 sleep a
 sleep b
 return stop w
 }
 // subtract b from a
 sub(a, b) {
 w = watch
 parallel {
 sleep a
 do {
 sleep b
 start w
 }
 }
 return stop w
 }
 // multiply two numbers
 mul(a, b) {
 w = watch
 start w
 forsplits (w, b) {
 sleep a
 split w
 }
 return stop w
 }
 // division
 div(a, b) {
 t = sub(b, 1)
 w = watch
 parallel {
 do {
 sleep a
 return time w
 }
 repeat {
 sleep t
 start w
 sleep 1
 stop w
 }
 }
 }
 min(a, b) {
 parallel {
 return sleep a
 return sleep b
 }
 }
 max(a, b) {
 parallel {
 do {
 sleep a
 return b
 }
 do {
 sleep b
 return a
 }
 }
 }
Category:Languages Category:2020 Category:Turing complete Category:Unimplemented