nyuuzyou/wikis huggingface dataset:
Suptiftam/Library

:
This page is a library of functions for Suptiftam.
==Math==
factorA~0
factorB~0
INTERNALTEMPfactorA~0
INTERNALTEMPfactorB~0
product~0
fd setFactorA :n
factorA=n
INTERNALTEMPfactorA=n
fi
fd setFactorB :n
factorB=n
INTERNALTEMPfactorB=n
fi
fd multiplyFactors :IGNOREPARAM
product=0
INTERNALmultiplyFactors(:IGNOREPARAM:)if(INTERNALTEMPfactorB)
INTERNALTEMPfactorA=factorA
INTERNALTEMPfactorB=factorB
fi
fd INTERNALmultiplyFactors :IGNOREPARAM
product=%+[product]INTERNALTEMPfactorA
INTERNALTEMPfactorB=%-[INTERNALTEMPfactorB]1
INTERNALmultiplyFactors(:IGNOREPARAM:)if(INTERNALTEMPfactorB)
fi
==Standard I/O==
fd writeln :tt
INTERNALwriteln(:tt:)if(:tt:)
down(:term:)
fi
fd INTERNALwriteln(:tt:)
term=tt
right(:term:)
right(:tt:)
INTERNALwriteln(:tt:)if(:tt:)
right(:term:)
left(:tt:)
fi
fd readlnInto ​:tt
down(:read:)
fi
fd INTERNALreadlnInto :tt
tt=read
right(:read:)
right(:tt:)
INTERNALreadlnInto(:tt:)IF(:read:)
left(:read:)
left(:tt:)
fi
Category:Examples
Surreal FOREVER loop

A Surreal FOREVER loop is an esoteric language construct that allows an infinite loop to be completed. Technically, it's certainly impossible in any Turing-complete language (you would need to solve the Halting Problem), but it's a nice idea.
== Structure ==
The Surreal Forever Loop is a loop that executes code infinitely many times in a finite period of time. It accomplishes this by analyzing the code provide and calculating what happens if you repeat it ad infinitum. This is, of course, impossible (what if the loop is calculating if a given Turing Machine has halted at a particular step? If you were to repeat that infinitely many times, it would be able to calculate what happens with the TM in the end- whether or not its halted (if it has, it halts at some point. If not, it never halts, thus solving the Halting Problem)). However, it may be possible for some restricted subset of Turing Machines or some other automaton- preferably, one which a TM can solve the halting problem for. Alas, these automata probably aren't particularly useful for mainstream programming.
Category:Language constructs
Surreal Numbers

The Surreal Numbers, or just Surreals, are an Esoteric (or should I say surreal? No. I shouldn't) numbering system (like the complexes or the naturals) that are pretty fucking weird (though they were invented to be).
In surreal numbers, the number { | } is called zero. { 0 | } is the number after 0 (some people like to call it 1). Likewise { 1 | } is the number after 1 (2), and so on. { | 0 } is -1, and so on in that direction as well.
{ 0, 1 | } is the number after 0 and 1, which is equivalent to { 1 | }. { 0 | 1 } is the number greater than 0 but less than 1, which is 1/2, and { 0 | 1, 1/2 } is 1/4.
We are allowed to have as many numbers on each side as we want, even an infinite number. { 0 | 1, 1/2, 1/4, … } is the infinitesimal, and { 0, 1, 2, … | } is infinity.
A more technical description can be found at Wikipedia:surreal number.
Attempts have been made to incorporate surreals into an esolang, but so far none have fully succeeded.
Category:Concepts
Surround notation

Surround notation is a lesser known notation, but it is, however, used in many languages. In surround notation, you put the command on both sides of its arguments. One example is parentheses: they are the identity function of surround notation. In xml, the primary notation is surround.
In Perl 6, an operator that uses surround notation is called circumfix.
== Examples ==
In html-style languages:
 <persons>
 <person>
 <name>Qwe Asd</name>
 <age>OVER 9000!!!</age>
 </person>
 </persons>
The general syntax for these kinds of surround operators is <tag></tag>.
In C-style languages:
 while(true) {
 //Do stuff
 }
It is the blocking operator {/*code*/} that is in surround notation. Other examples include array[index] and "string".
In the mathematical notation the absolute value operator |x| is in surround notation.
== Uses of surround notation ==
Surround notation is generally essential for operations with a variable arity. For example, consider the following Python code:
 a = ( [1, 2, 3], [-1, -2, -3] ) #a pair of lists with length 3
If the surround notation of the square brackets were omitted, the code would mean something different.
 a = ( 1, 2, 3, -1, -2, -3 ) #one hexad of integers
The brackets are therefore required for delimiting an arbitrary number of sequential values from their surroundings.
Category:Concepts
Category:Operator_notations
SusLang

SusLang is an among-us-themed esolang written in C#.
It was invented by Zenonet (a German hobby programmer) in 2022.
You can find more information about SusLang here
Also there is an online interpreter available here
The language isn't turing complete because it doesn't have an infinite amount of possible variables. Instead it has 18 variables named after the 18 player colors is Among Us.
Every variable/color has a value (1 byte) assigned to it, which is called the 'SusMeter'.
It determines how sus a color is.
You can change the SusMeter of a color using these 4 statements:
* <color> killed increases the value of <color> by 10
* <color> vented increases the value of <color> by 1
* <color> wasWithMe decreases the value of <color> by 10
* <color> didVisual decreases the value of <color> by 1
You can select a color using sus<color>
Using emergencyMeeting you can write the value of the currently selected color to the output.
Instead of writing the name of a color in a statement, you can also you he as a reference to the currently selected color
You can write a helloWorld-script like this:
 //This is a simple HelloWorld script for susLang
 
 // Writing H
 sus cyan
 cyan killed
 cyan killed
 cyan killed
 cyan killed
 cyan killed
 cyan killed
 cyan killed
 cyan vented
 cyan vented
 emergencyMeeting
 
 // Writing e
 cyan killed
 cyan killed
 cyan killed
 cyan wasWithMe
 emergencyMeeting
 
 // Writing l
 cyan killed
 cyan wasWithMe
 cyan wasWithMe
 cyan wasWithMe
 emergencyMeeting
 
 // Writing the l again
 emergencyMeeting
 
 // Writing o
 cyan vented
 cyan vented
 cyan vented
 emergencyMeeting
 
 // Writing a space
 sus red
 red killed
 red killed
 red killed
 red vented
 red vented
 emergencyMeeting
 
 // Writing W
 sus cyan
 cyan didVisual
 cyan didVisual
 cyan wasWithMe
 cyan wasWithMe
 cyan wasWithMe
 cyan wasWithMe
 emergencyMeeting
 
 // Writing o
 cyan killed
 cyan killed
 cyan vented
 cyan vented
 cyan vented
 cyan vented
 emergencyMeeting
 
 // Writing r
 cyan vented
 cyan vented
 cyan vented
 emergencyMeeting
 
 // Writing l
 cyan didVisual
 cyan vented
 cyan vented
 cyan vented
 cyan vented
 emergencyMeeting
 
 // Writing d
 cyan didVisual
 cyan vented
 cyan vented
 emergencyMeeting
 
 // Writing !
 sus red
 red vented
 emergencyMeeting
Category:Languages Category:Total Category:Thematic Category:Pseudonatural Category:2022 Category:Implemented Category:Sus
Suscript

Suscript is a cell-based esolang by people in the amogus esolang crew, this page is a WIP.
== Instructions ==
eject "string" 	Print a string
when the impostor is sus 😳 	If tape[ptr] Then
among drip 	End-If
imposter sus 	tape[ptr] = 1
imposter safe 	tape[ptr] = 0
amogus goes to the next sus town 	ptr++
amogus goes to the previous sus town	ptr--
say <label> 	Goto <label>
become the <label> 	Define Label <label>
is impostor sus? 	Input, if "sus" then tape[ptr]=1 elseif "not sus" then tape[ptr]=0
== Examples ==
=== Truth machine ===
is imposter sus?
when the imposter is sus 😳:
 become the loopus
 eject "1"
 say loopus
among drip
eject "0"
=== Cat program ===
become the loopus
 is imposter sus?
 when the imposter is sus 😳:
 eject "Sus"
 say loopus
 among drip
 eject "Safe"
 say loopus
=== Hello World ===
eject "Hello, world!"
== Computational class ==
Suscript is turing-complete since any program in it can relatively easily be converted to brainfuck but with bits.
== Implementations ==
https://github.com/aouwt/suscript Compiler in qb64 by User:Not_applicable
Category:Languages
Category:Cell-based
Category:2021
Category:Turing complete
Category:Implemented
Category:Sus
Suscript 2.0

Suscript 2.0 is another esolang by the amogus esolang crew. It is based on a 1D array of floating-point number cells, all initalized with 0.
== Instructions ==
[n] is an optional number literal. {n} is a mandatory number literal. They can be written in decimal (12.34), hexadecimal (ඬ5B3) or Unicode (ඞg). ච pops the stack and returns it.
 
eject "string" 	Print a string.
Escape codes:
ඬ - Newline
ඩ - Tab
ඞ - Numeric value of current cell
ඪ - Numeric value of current cell (hexadecimal)
ච - Character value of current cell
imposter sus [n] 	tape[ptr] = n (default 0)
imposter more sus [n] 	tape[ptr] += n (default 1)
imposter less sus [n] 	tape[ptr] -= n (default 1)
imposter very sus [n] 	tape[ptr] *= n (default 10)
imposter barely sus [n] 	tape[ptr] /= n (default 10)
imposter extremely sus [n] 	tape[ptr] **= n (exponentation) (default 2)
imposter hardly even sus [n] 	tape[ptr] %= n (remainder) (default 10)
imposter safe 	tape[ptr] = !tape[ptr] (logical not, 1 if <=0 and 0 if >0)
amogus goes to the next sus town [n] 	ptr += n (default 1)
amogus goes to the previous sus town [n]	ptr -= n (default 1)
when the impostor is sus 😳 	if tape[ptr] > 0 then
when the imposter is safe 	if tape[ptr] <= 0 then
how sus is imposter? 	accept numerical input to current cell
why is imposter sus? 	accept numerical input to current cell (hexadecimal again)
where is imposter? 	accept character input to current cell
say <label> 	goto <label>
become the <label> 	define <label>
imposter go into of the vents 	push current cell value to stack
imposter come out of the vents 	pop from stack to current cell
amogus 	print "amogus" (I'm sorry).
GETOUTOFMYHEAD 	depends on how many times it is repeated:
1: sine current cell
2: cosine current cell
3: tangent current cell
4: arcsin current cell
5: arccos current cell
6: arctan current cell
7: log10 current cell
dead body reported 	while tape[ptr] > 0 do
emergency meeting 	while tape[ptr] != top of stack do
red was the imposter 	end while
when the imposter is t h i c c 	tape[ptr] = length of stack
imposter pulls out a knife and kills you	end program
==Examples==
===Hello, World!===
 eject "Hello, World!"
===Infinitely print Fibonacci sequence===
 imposter more sus
 dead body reported
 eject "ඞඬ"
 dead body reported
 imposter less sus
 amogus goes to the next sus town
 imposter more sus
 amogus goes to the next sus town
 imposter more sus
 amogus goes to the previous sus town 2
 red was the imposter
 amogus goes to the next sus town
 red was the imposter
Category:Languages Category:Sus Category:Thematic Category:Pseudonatural Category:Joke languages Category:Cell-based Category:Stack-based Category:Turing complete
Sushi Conveyor

Sushi Conveyor is 2-dimensional language based on the conveyor belt sushi restaurants. It's created by User:Evylah after getting the idea when vising Japan.
== Overview ==
Sushi Conveyor code contains a few (replace with actual number) components. Those are
* the actual conveyor
* seats (X)
* sushi (that goes around)
* online ordering (for user input)
** computer (to actually use the input)
Each component does a different thing.
=== The conveyor ===
This is where all the sushi has to be transported. It is marked with the characters >, ^, < and v. These four characters represent the direction of the conveyor. The number of conveyors isn't limited to just one. There are also more characters that can change the direction based on a condition.
=== Seats ===
When a sushi reaches a seat, it will be eaten and its value will be outputted to the console. Outputting can also be done by a direct string.
=== Online ordering ===
When the "check online for orders" command is run (i), the program will request a number from the user. Then, any computers with conveyors connected to it will spawn a sushi. If multiple sides are connected, it will send it to all sides.
== Instructions ==
=== Conveyor belt ===
Conveyors cannot cross, although sushi can be launched one space or however many spaces as its value to get over an overlapping belt.
Character	Description
> ^ < v 	Change the direction of where the sushi is moving.
 	
 	
 	
 	
 	
 	
Category:Languages Category:2024
Suzy

Suzy is a 3D esoteric programming language, inspired by Befunge, superseding 3D. Suzy source is compiled to byte-code in the original implementation. Comments are made by directing code flow around them. It includes file I/O as well as STDIN/STDOUT. Every non-control ASCII character is used as an operation or variable name.
== Commands ==
 No-op:
 	 (space) do nothing
 	| vertical pipe (do nothing)
 	- horizontal pipe (if not in math mode)
 	' lateral pipe
 Execution control:
 	@ end
 Flow control:
 	{ right
 	} left
 	^ up
 	_ down
 	[ forwards
 	] backwards
 	% random direction
 	# jump
 	$ conditional jump
 Conditional jump preparation:
 	= equality
 	< smaller than
 	> greater than
 Input/output:
 	? input
 	! output
 File access:
 	/ open a file for input and output
 Libraries:
 	+ load a library
 Variable handling:
 	: set a variable to a value
 	( enter math mode
 	) leave math mode
 	" enter/leave unicode mode
 	. cat strings
 	, substring
 	~ swap two variables
 String mode:
 	` temporary escape unicode mode, for changing directions
 	\ escape sequence
 Math mode:
 	+ addition
 	- subtraction
 	* multiplication
 	/ division
 	% modulus division
 Numeric:
 	0-9 numeric constants
 Variable names:
 	A-Z string variable names
 	a-z integer variable names
 	\ indirect variable mode (if not in ascii/unicode mode)
 Arguments:
 	; separates 2 arguments
 Unused:
 	& unused in Suzy proper (except in strings, of course), but can be used in a Suzy source file to separate sheets
== Example ==
The following lists all primes up to a given bound:
 32,7,3
 }!"Primes up to: "?A ~Aa ]
 a is the maxprime
 p is the index of the stack
 stack is the list of primes
 n is the number that is
 checked for primeness
 i is a temp stack index
 &
 ] 3n:1p: "2"! _$0001a> 2;0\:{
 }!"Too large!\n"@
 &
 } >na$@ --- :i0 } =(n/\i*\i)n _
 | ^---------{ $
 | }:i(i+1)^ #
 | _p:p\!np\:" ,"!^$)n/(i\< {
 | }(p+1) _ |
 ^--)1+n(n: {------------------{
== Computational class ==
The author thinks Suzy is Turing Complete, because it is possible to translate any BrainFuck program to Suzy:
 > becomes :p(p+)
 < becomes :p(p-)
 + becomes :\p(\p+)
 - becomes :\p(\p-)
 [ becomes }=\p0$_ (with a pipe from _ to the corresponding })
 ] becomes _} (with a pipe from _ to the corresponding })
Input and output work differently, but could be translated as:
 , becomes ?\p
 . becomes !\p
However, I/O is not necessary for Turing Completeness, so that doesn't matter.
== Implementation ==
A full featured implementation in Python of both byte-code compiler and interpreter are on GitHub.
Category:Languages
Category:2009
Category:Multi-dimensional languages
Category:Stubs
Category:Usability unknown
Category:Turing complete
Category:Implemented
Swap

Swap is a language based on string rewriting. It was created by User:revcompgeek in August 2009.
== Overview ==
When the program is run, the first character is removed. If it is not a ~ or a \ it is output. When a \ is removed the next character is removed and output. When a ~ is encountered, a construct is read like this:
 ~string1~string2~
Escaped characters are treated as themselves in string1 and string2, then instances of string1 and string2 are then swapped in the program code. Since swapping nothing with nothing is useless, if both string1 and string2 are empty then text is read up to the next ~, and then the text is replaced with a character read from stdin. Example: in this
 ~Hello~World~World Hello!
~Hello~World~ is removed from the beginning, leaving this:
 World Hello!
Then the two strings Hello and World are swapped in the text. Every time Hello appears, it is replaced with World and vice versa. The code then becomes this:
 Hello World!
Which is then sent to stdout.
Since if string1 and string2 are equal swapping is useless, the code is scanned for the string. If only 1 instance is found then the left and right halves of the code are swapped around the found string. Example:
 ~|~|~ 123|456
Becomes:
 456|123
If two instances are found then the code is swapped like 12|34|56 -> 56|34|12. And if 3 instances are found then the code is swapped like this: 1|23|45|6 -> 1|45|23|6. Right now this is as far as the swapping construct goes, but more may be added if it can be shown to be useful.
When instances of string1 and string2 overlap, the one that occurs first takes precedence, and if they start on the same character string1 takes precedence. Example:
 ~123~12312~ 12312
becomes:
 1231212
== Examples ==
Hello World!
 Hello World!
Or a slightly more complicated version
 ~World~Hello~~!~?~World Hello?
== Interpreter ==
The official interpreter is here. It is written in D and uses the Tango standard library. I have been unable to find any bugs so far in the current revision, but if any are found I can be contacted either through GitHub (preferred because of email notifications) or this wiki (which I may not check often).
== Notes ==
~ was chosen due to it's similarity to the transpose revision symbol.
Category:Languages
Category:String-rewriting paradigm
Category:2009
Category:Low-level
Category:Self-modifying
Swapfuck

swapfuck is a brainfuck derivative by User:Rdococ, which replaces the typical increment and decrement instructions with a single 'swap' instruction.
== Differences from brainfuck ==
* Input is loaded into the tape at the beginning of execution.
* Cells can only hold a 0 or a 1.
* The only instruction that modifies the tape is @, which swaps the contents of the current cell with the cell to the right.
== Instruction set ==
Instruction	Description
@ 	Swaps the values of the current cell and the cell to the right.
< 	Move the cell pointer to the left.
> 	Move the cell pointer to the right.
[ 	Jump past the matching ] if the current cell has a value of 0.
] 	Jump back to the matching [ if the current cell has a non-zero value.
. 	Adds the bit at the current cell to the output queue. When the output queue reaches a size of 8, it is emptied and the corresponding UTF-8/ASCII character is printed.
== Computational class ==
If the input tape contains sufficient consecutive pairs of 1 0, a swapfuck program could trivially operate on each pair as if it was a single, flippable bit.
If swapfuck's [] loops were replaced with ones that looped while the current cell was zero, not non-zero, a finite input tape of 1 1 1 1 1 1 would allow a program to simulate three-cell unbounded brainfuck, which is Turing complete.
The tape is split into 6 interleaved streams of bits. The first stream has a 1 at the position matching the value of the first register, the second stream has a 1 at the position matching the second register, and so on. The other three streams are never permanently modified, and serve only to allow seeking the beginning of the tape while preserving which register is currently selected. This is reducible to 4 bit streams (and therefore 4 1s) if this is not required.
Conjecture: swapfuck remains Turing-complete even using only the while non-zero loops, if given a specific, finite input. This could be done by lugging 1s along as it scans the tape so it can invert each cell it scans on the fly.
== Implementation ==
A rough implementation of swapfuck in Lua is available here.
Category:Languages Category:Cell-based Category:Implemented Category:Low-level Category:Brainfuck derivatives
Swapfuck/Implementation

:
Here is a rough implementation of swapfuck in Lua. The "while zero" loop described in the main article has been included in this interpreter as {}.
return {
	run = function (wc, tape)
		local wc = wc:gsub("[^%@%<%>%[%]%{%}%.]", "")
		
		local tape = tape or {}
		local cell = 1
		local stack = {}
		
		local buffer = 0
		local buffersize = 0
		
		local i = 1
		while i <= #wc do
			local char = wc:sub(i, i)
			
			-- Basics
			if char == "@" then
				tape[cell], tape[cell + 1] = tape[cell + 1], tape[cell]
			elseif char == "<" then
				cell = cell - 1
			elseif char == ">" then
				cell = cell + 1
			
			-- While
			elseif char == "[" or char == "{" then
				if (char == "{") ~= (tape[cell] ~= nil and tape[cell] ~= 0) then
					table.insert(stack, {type = "while", ip = i})
				else
					local depth = 1
					i = i + 1
					while depth > 0 do
						local char = wc:sub(i, i)
						if char == "[" then depth = depth + 1
						elseif char == "]" then depth = depth - 1 end
						i = i + 1
					end
					i = i - 1
				end
			elseif char == "]" or char == "}" then
				if (char == "}") ~= (tape[cell] ~= nil and tape[cell] ~= 0) then
					i = stack[#stack].ip
				else
					table.remove(stack)
				end
			
			-- Output
			elseif char == "." then
				buffer = buffer * 2 + ((tape[cell] and tape[cell] ~= 0) and 1 or 0)
				buffersize = buffersize + 1
				
				if buffersize == 8 then
					io.write(string.char(buffer))
					buffer, buffersize = 0, 0
				end
			end
			i = i + 1
		end
		return tape
	end
}
Category:Implementations
Swapper

Swapper is a simple self-modifying reversible language invented by User:Tailcalled in February of 2012.
== Syntax ==
Swapper programs consist of a list of statements separated by semicolons:
 program = statement [';' program]
 statement = <atom> '<->' <atom>
 statement = '(' <#> ')' ('<+->' | '<*/>') '[' <#> ']'
 statement = '<rev>'
 statement = '<prtmd>'
where <atom> is a string of characters in the groups A-Z, a-z, or 0-9, and <#> is just in the group 0-9.
== Programming ==
=== Integers ===
Integer literals are created by putting an integer in parentheses.
 (42)
Constant integer literals are created with brackets instead. These have the property of remaining unchanged during a pseudo-operation.
 [42]
=== Operators ===
Operators are enclosed in angle brackets and self-modify the program when executed. They cannot be modified themselves.
Syntax 	Action
A <-> B; 	swaps all occurrences of A and B, where both are alphanumeric patterns delimited by ; and <->. Invalid characters (spaces, newlines, symbols, etc.) are skipped in the pattern. Text inside [] or <> remains unchanged during the swap.
(x) <+-> [y];	replaces (x) with (x+y) if the program flows forward, and (x-y) if backward.
(x) <*/> [y];	replaces (x) with (x*y) if the program flows forward, and (x/y) if backward, rounding down.
<rev>; 	reverses program flow.
<prtmd>; 	toggles "print mode". In this mode, any number that <->'s with out is printed to STDOUT.
Additional operators can be added at the programmer's discretion. User:Tailcalled encourages this notion to add power to the language while maintaining its reversibility.
== Sample Programs ==
=== Operator Demo ===
This program prints 1 to STDOUT.
 i <-> (0);
 i <+-> [1];
 <prtmd>;
 out <-> i;
 <prtmd>;
Step by step:
1. All is are swapped with (0):
 (0) <-> i;
 (0) <+-> [1];
 <prtmd>;
 out <-> (0);
 <prtmd>;
2. All (0)s are incremented.
 (1) <-> i;
 (1) <+-> [1];
 <prtmd>;
 out <-> (1);
 <prtmd>;
3. Enter print mode.
4. 1 printed because it is in print mode.
5. Exit print mode.
=== Print the ASCII #s of Hello, world! ===
 <prtmd>;
 out <-> (72);
 out <-> (101);
 out <-> (108);
 out <-> (108);
 out <-> (111);
 out <-> (44);
 out <-> (32);
 out <-> (119);
 out <-> (111);
 out <-> (114);
 out <-> (108);
 out <-> (100);
 out <-> (33);
 out <-> (10);
Category:Languages
Category:2012
Category:Unimplemented
Category:Reversible computing
Category:Output only
Swearjure

Swearjure is an esoteric subset of Clojure, that comes from the restriction of not using alphanumeric characters. It was invented in November 2012.
== Description ==
The most important part of Swearjure is to avoid using alphanumeric characters, other than that it has to be a valid Clojure program. 
== Examples ==
Numbers:
 (+) ;=> 0
 (*) ;=> 1
 (+ (*) (*)) ;=> 2
Factorial:
 (#((% (+)) % (`[~@%&] (+))); Call factorial with all fns and n
 
 [#((% ({(+) (*)} (`[~@%&] (+)) (+ (*) (*))))
 % (`[~@%&] (+)))
 #({} %& (*))
 #(* (`[~@%&] (+))
 ((% (+)) % (- (`[~@%&] (+)) (*))))]
 6)
== See also ==
* JSFuck
== External Links ==
* http://hypirion.com/musings/swearjure - Original creation
* http://hypirion.com/musings/swearjure-is-turing-complete - TC construction
Category:Esoteric subset
Category:Languages
Category:2012
Category:Functional paradigm
Category:Turing complete