nyuuzyou/wikis huggingface dataset:
SF Code

SF Code is a programming language based on using San Fransisco symbols as code.
It was created by Jayden Irwin in 2021.
Official Page
== Description ==
This is a grid based language. The main idea is to have variable symbols (integers 0-50) move around the grid while the grid symbols can apply different operations on the variables. Variables always move 1 space per step unless being blocked. The default direction is right, although arrows and other symbols can change the variable's direction. SF Code is a powerful language with many features such as user input and random number generation. SF Code was inspired by ASCII-Dots, and other esolangs.
 Symbols
Symbol 	Action
Variable 	Hold integer values (0-50) and move.
Arrows (^,v,<,>)	Point variables in a new direction.
Duplicate 	Creates 2 copies of the variable and moves them in opposite directions.
Toggle 	Turns on/off surrounding blocks, and flips surrounding arrows.
Block 	Stops variables from entering this location (when enabled).
Trash 	Deletes variables.
Math (+,-,*,/,%)	Applies operation to variable using surrounding constants and other variables at the location.
Equals 	Points variable in direction of equal constants surrounding the equals location.
Constant 	Holds integer (0-50).
Die 	Rolls a value 1-6 each time it is read.
Input 	Replaces the variables value with a user entered value.
Print 	Outputs variable value to console.
Sound 	Plays sound.
Stop 	Ends execution.
=== Variable Overflow ===
There is no overflow. Results over 50 (ex: 50 + 1) will be capped at 50. Results less than 0 will be capped to 0.
== How To Try ==
Download the SF Code app on iOS, iPadOS, or macOS.
Category:languagesCategory:cell-basedCategory:non-textualCategory:unknown_computational_classCategory:implementedcategory:thematiccategory:high-levelCategory:2021Category:Self-modifying
SGMJQFuck

SGMJQFuck is a brainfuck deriviative created in 2012 by User:X0wl. Although it supports all the brainfuck fuctionality and instructions, it has extensions to allow the self-modifying code.
==Language overview==
This language is an extended variation of the brainfuck language, extensions allow the self-modifying code.
It has 3 pointers:
# Memory pointer - points to the current cell in the data array
# Code R/W pointer - points to the current cell in the code array. Code Reading/Writing uses this pointer to access the code.
# Execution pointer - points to the cell in the code array that is currently executed. Increments after each instruction (except [,],j)
===Commands===
Command	Description
> 	Move the memory pointer to the right
< 	Move the memory pointer to the left
+ 	Increment the memory cell under the pointer
- 	Decrement the memory cell under the pointer
. 	Output the character signified by the cell at the pointer
, 	Input a character and store it in the cell at the pointer
[ 	Jump past the matching ] if the cell under the pointer is 0
] 	Jump back to the matching [ if the cell under the pointer is nonzero
s 	Set the code R/W pointer to the value of the current cell
j 	Jump to the address in the current cell
m 	Set the code cell under the code R/W pointer to the character signified in the current cell
g 	Set the current cell to the ASCII code of the code cell under the code R/W pointer
q 	Stop program execution
==Example programs==
===Quine===
 g.[<+>[-]j][-]+++++++++++++.q 
==Implementation==
It was implemented by author (but in Windows PowerShell): http://pastebin.com/kcBJibHr
Category:Turing complete
Category:Turing tarpits
Category:Languages
Category:2012
Category:Implemented
Category:Brainfuck derivatives
SHAat

SHAat stands for Secure Hash Algorithm automata, and is pronounced shat. SHAat stores information as a doubly infinite two dimensional array of Boolean values. At the start of a SHAat all of the values are set to 0. SHAat commands can be split up into three types. The first type is read and write commands. Any data location can be set to 1, 0, or user's input using square brackets and a standard = expression and the key word input. Some examples of this are:
 [0,0] = 1
 [-1,2] = 0
 [10,100] = input
Note you are not able to use a value saved at one location to set a value save at another relocation.
The next type of commands are the out commands. These are written with the key word out then a type and finally an ordered list of locations that make up a binary string. An example of this might be:
 Out bool {[0,0]}
 Out char {[0,0],[0,1],[5,7],[6,10],[21,21],[-1,-1],[,5,5],[0,0]}
The out command prints directly out and can not be used to effect the running program. 
The final command is SHAat which gives the language its name. SHAat can either take an integer or a string which it will convert to an integer. After this SHA-512 is run on its input. This will return a 512 bit sequence. This sequence is then used to define a rule set for a fundamental two dimensional cellular automaton. These rules are then followed for a single step over the whole grid.
== Fundamental two dimensional cellular automata ==
A fundamental two dimensional cellular automaton is a two dimensional cellular automaton where the value of each cell during the next iteration only depends on its current value and the value of its 8 surrounding cells. These cells form a 3 by 3 square that can take on 512 different states. Each of these states can be given a number x. For example x is 0 when all 9 of the cells are 0, x is one when only the top left cell is 1, and so on. From here every rule set can be described with a 512 bit number where the xth bit is 1 if a cell in the center of and x state 3 by 3 square will become 1 and the xth bit is 0 if it will become 0.
Category:Languages Category:2020
SHITS

SHITS (Simple language witH bITS) is an esolang by User:ChuckEsoteric08 based on brainfuck minimalisations which uses binary tape.
==Specification==
Language uses right-infinite tape.
==Commands==
 ! - flip bit and move to the first cell
 > - move right
 {...} - while not zero
Optional I/O commands:
 * - output bit
 + - input bit
==Computational class==
Language is Turing-complete, because it can simulate Cyclic Tag with initial string of 1:
 Program start - !>>>!{
 ; - {>>}>>!{>>}!
 0 - {>>}>{!!>>{>>}>>{>>}!>>{>>}}!{>>{>>}>!}!
 1 - {>>}>{!!>>{>>}>>{>>}>!>>{>>}>>{>>}!>>{>>}}!{>>{>>}>!}!
 Program end - }
It also proves that it is Turing-complete even with maximum nesting depth of 3.
==Interpreter==
===In Python 3===
def interpret_shits(program):
 brackets = match_brackets(program)
 if brackets is None:
 raise SyntaxError("brackets are unmatched")
 
 cells = set()
 cell_pointer = 0
 i = 0
 
 while i < len(program):
 c = program[i]
 
 if c == "!":
 cells ^= {cell_pointer}
 cell_pointer = 0
 elif c == ">":
 cell_pointer += 1
 elif c == "{":
 if cell_pointer not in cells:
 i = brackets[i]
 elif c == "}":
 if cell_pointer in cells:
 i = brackets[i]
 elif c == "*":
 print("1" if cell_pointer in cells else "0", end=" ")
 elif c == "+":
 if input() != "0":
 cells.add(cell_pointer)
 elif cell_pointer in cells:
 cells.remove(cell_pointer)
 
 i += 1
def match_brackets(program):
 temp = []
 result = {}
 
 for i, c in enumerate(program):
 if c == "{":
 temp.append(i)
 elif c == "}":
 if len(temp) == 0:
 return None
 matched = temp.pop()
 result[matched] = i
 result[i] = matched
 
 return result if len(temp) == 0 else None
===In CDILOI===
// ! - flip bit and move to the first cell
// > - move right
// {...} - while loop
// * - output bit
// + - input bit
INP RCODE
CONC @RDATA 0! RDATA
CONC @LDATA ! LDATA
CONC ! @NEST NEST
LBL CMD
IF @RCODE @A HALT
DEL @RCODE CMD RCODE
CONC @CMD @LCODE LCODE
IF @CMD ! FLIP
IF @CMD > RIGHT
IF @CMD * OUT
IF @CMD + INP
IF @CMD { SLOOP
IF @CMD } ELOOP
IF A A CMD
LBL FLIP
DEL @RDATA BIT RDATA
IF @BIT 0 SET1
IF @BIT 1 SET0
LBL SET1
CONC 1 @RDATA RDATA
IF A A LEFT
LBL SET0
CONC 0 @RDATA RDATA
IF A A LEFT
LBL RIGHT
DEL @RDATA BIT RDATA
CONC @BIT @LDATA LDATA
IF @RDATA ! NEWR
IF A A CMD
LBL NEWR
CONC 0 @RDATA RDATA
IF A A CMD
LBL LEFT
DEL @LDATA BIT LDATA
CONC @BIT @RDATA RDATA
IF @LDATA ! CMD
IF A A LEFT
LBL OUT
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
OUT @BIT
IF A A CMD
LBL INP
DEL @RDATA BIT RDATA
INP BIT
CONC @BIT @RDATA RDATA
IF A A CMD
LBL SLOOP
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
IF @BIT 0 FIND}
IF A A CMD
LBL FIND}
DEL @RCODE CMD RCODE
CONC @CMD @LCODE LCODE
IF @CMD { INCNEST1
IF @CMD } DECNEST1
IF A A CMD
LBL INCNEST1
CONC * @NEST NEST
IF A A FIND}
LBL DECNEST1
IF @NEST ! CMD
DEL @NEST CMD NEST
IF A A FIND}
LBL ELOOP
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
IF @BIT 1 FIND{
IF A A CMD
LBL FIND{
DEL @LCODE CMD LCODE
CONC @CMD @RCODE RCODE
IF @CMD { INCNEST2
IF @CMD } DECNEST2
IF A A CMD
LBL INCNEST2
CONC * @NEST NEST
IF A A FIND{
LBL DECNEST2
IF @NEST ! CMD
DEL @NEST CMD NEST
IF A A FIND{
LBL HALT
Category:Languages Category:Turing complete Category:Turing tarpits Category:Implemented Category:Cell-based
SIC-1 Assembly Language

SIC-1 Assembly Language is the primary (and, currently, only) language used for programming SIC Systems's Single-Instruction Computer, Mark 1 (SIC-1). The SIC-1 is a fictional 8-bit computer used in a web-based programming game (of the same name--see #External Resources for a link) that, as its name implies, only supports a single instruction: subleq (subtract and branch if less than or equal to zero).
==Language Overview==
Command 	Description
subleq A B [C]	mem[A] = mem[A] - mem[B]; branch to C if result <= 0
@label 	Associates a label with the address of the following command
.data X 	Sets the next byte of memory to a value at compile time
Note that if the third address (C) for subleq is omitted, the address of the next instruction is used (in other words, the branch would have no noticeable effect).
===Binary representation and offsets===
Each subleq A B C instruction is stored as 3 consecutive addresses (each one byte): ABC.
When referring to a label, you can include an offset (specified in bytes), e.g. @label+1. See the self-modifying code example for a practical application of this.
===Built-in labels===
The following predefined lables are always available:
* @MAX (252): Maximum user-modifiable address
* @IN (253): Reads a value from input (writes are ignored)
* @OUT (254): Writes a result to output (reads as zero)
* @HALT (255): Terminates the program when executed
==Examples==
===Negation===
This program negates one input value and outputs the negated value.
 subleq @OUT, @IN
===Continuous negation===
This program reads values, negates them, and outputs them in an infinite loop.
 @loop:
 subleq @OUT, @IN
 subleq @zero, @zero, @loop
 
 @zero: .data 0
===Self-modifying/referencing code===
The sample program below reads its own compiled code and outputs it by incrementing the second address of the instruction at @loop (i.e. modifying address @loop+1).
 @loop:
 subleq @tmp, 0 ; Second address (initially zero) will be incremented
 subleq @OUT, @tmp ; Output the value
 subleq @loop+1, @n_one ; Here is where the increment is performed
 subleq @tmp, @tmp, @loop
 
 @tmp: .data 0
 @n_one: .data -1
==See also==
* Subleq
==External Resources==
* SIC-1 programming game: https://jaredkrinke.itch.io/sic-1
Category:Languages
Category:Programming games
Category:Implemented
Category:2019
SIG

SIG is a language based on signals that was created on May 16, 2008 by revcompgeek. There are two data structures. The first data structure is stack like, but it is more like a napkin holder at restaurants. Simply pushing or pulling (popping) won't do anything. Instead you have to shove and yank. The second data structure is like a tape, but is more like a conveyor belt with no motor. Instead of you moving along the belt, you have to move the belt to where you want it by pushing and pulling it. Numbers in the napkin holder are called napkins, and numbers on the belt are called items.
== Commands ==
 SIG signal
Start of a signal block. Only executes if signal has been tripped during the previous run.
NOTE: the signal tick is tripped at the end of every run.
 TERM
Ends a signal block.
 TRIP signal
Trips the signal and causes any same-named signal blocks to be executed turing the next run.
 RESET signal
Resets the state of the specified signal. If it was previously tripped during the current run, this undoes what the TRIP command did, which means it will no longer be active during the next run.
 PRY
This pries a char from the input stream and shoves it into the napkin holder.
 CRAM
This yanks front napkin out of the napkin holder and stuffs it into the output stream as a character, modulo 256 if needed.
 IF condition command
IF is a comparison command that compares the current item with the front napkin. Condition can be any of the following:
 LESS - less than
 MORE - greater than
 GOOD - equal to
 EVIL - unequal to
 CLEAN - napkin holder is empty
 DIRTY - napkin holder has something
If the condition is satisfied, then command is executed.
 GROW
Adds the front napkin to the current item and burns it.
 GROW BY value
Adds value to the current item.
 SHRINK
Subtracts the front napkin from the current item and buns it.
 SHRINK BY value
Subtracts value from the current item.
 ENLARGE
Multiplies the front napkin by the current item and burns it.
 ENLARGE BY value
Multiplies the current item by value.
 REDUCE
Divides the current item by the front napkin and burns the napkin.
 RECUDE BY value
Divides the current item by value.
 PURGE
Resets the current value on the belt to zero.
 BURN
Burns the front napkin.
 SHOVE
Shove the current value on the belt into the napkin holder.
 YANK
Yanks the top value out of the napkin holder and put it onto the belt in place of the old value.
 CLONE
Duplicates the front napkin and shoves the new one into the napkin holder.
== Example programs ==
The following is the cat program that ignores EOF:
 SIG tick PRY CRAM TERM
Category:Languages
Category:2008
SIMPLE (preprocessor)

SIMPLE is a text preprocessor created by David Madore in 1998, inspired by m4. SIMPLE got its name from the joke language SIMPLE.
SIMPLE has special syntax to expand a function parameter with each of its tokens quoted, which is necessary to be able to define functions that take a parameter by reference. Just like TeX, SIMPLE works on a list of tokens, so can have individual tokens quoted, or every token in a token string quoted, but not expressions quoted as a whole. Quoting a token string multiple levels involves blowing its size up exponentially. SIMPLE is thus based on the leaning toothpick syndrome, in which every time you refer to a parameter in a function definition, you have to decide how many times deep you want to quote that argument to make sure that everything gets evaluated at the right time. Too few or too many and your program won't work.
* Reference manual of SIMPLE
* Download page for the SIMPLE implementation
* SIMPLE listed in David Madore's list of published software
* Announcement, including an obfuscated hello world program
Category:Languages
Category:1998
Category:Implemented
Category:String-rewriting paradigm
Category:Turing complete
Category:Output only
SIMPLE (the other one)

SIMPLE (the other one) is a joke esolang made by User:Yes thats a parody of SIMPLE
== Acroynm ==
Simp Linguistic Environment
== Conversion from SIMPLE to Simp Linguistic Environment ==
 Caption text
Header text	Header text
STOP 	Stop watching stream
BEGIN 	Start watching stream
END 	Close computer
== Simple (the other one) in the real world ==
yes, this is ripped from the Nothing article
Simple (the other one) was made in under a minute, and this article was made in under five minutes.
There is an impossiblity of programs in SIMPLE (the other one). So it is assumed to be useless.
== Sample program ==
NOP
Close computer
== Interpeter ==
https://tio.run/##bYtLCgIxEET3nqKXumrBG6iDuBmFmQuEWJhAfqRbPX5s924K6r0qSU4CZAw@TpfrzIu6rvRx6kMsTxLtcJk3vKy3u8na/rhpPvMpVQH5mttL0Q2uIQrFYqXBwm5C2T1gjA57EnihbUeub5D@tikW7Mb4Ag
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Total
Category:Thematic
Category:Pseudonatural
SKNPR Calculus

SKNPR Calculus is an esoteric computational model invented by User:Hakerh400 in 2022.
== Overview ==
SKNPR calculus has the following combinators: S, K, N, P and R. It has the following reduction rules:
 K a b ---> a
 S a b c ---> a c (b c)
 R a b N ---> a
 R a b (P c d) ---> b c d
Two combinators are equal iff they have the same name. Two expressions are equal iff both of them can be reduced to the same expression using reduction rules, plus function extensionality (Expression a is equal to expression b if for any expression x, expressions a x and b x can be reduced to the same expression).
Category:Languages
Category:Functional paradigm
Category:Turing complete
Category:Unimplemented
Category:2022
SKOAL

SKOAL is an esoteric printed circuit board used in production in the HP 9825T desktop calculator. 
The HP 9825B is a desktop calculator with close to 32 kilobytes of ROM and 32 kilobytes of RAM. The HP 9825T is a closely related desktop calculator that extends the RAM size to 64 kilobytes. This was a nontrivial problem because the CPU only has a 16-bit byte-granular address space, so there should be no way to fit more than 64 kilobytes. The usual solution for this would be bank switching logic. That, however, would have required a rewrite of the already pretty mature system software in the ROM. So instead the engineers Rick Dow and Richard Herrington created an esoteric solution. 
Apart from the extra 32 kilobytes of DRAM chips and the RAM decode and control logic, the Skoal circuit board contains logic to divine whether a memory access is supposed to be for the ROM or RAM. The inputs for this use bus lines that were, before this board, considered debug lines used to develop the calculator. These expose some important information from the CPU that would not normally be needed for the logic, most importantly which memory reads are fetching an instruction. Instructions are executed almost only from the ROM, except for a certain designated area of the RAM. The hard cases come from data reads, which could typically refer either the ROM or RAM. Since the ROM software was mature at this point, the engineers annotated all of the code to mark which instructions in it fetch data from ROM versus RAM, and this information was encoded in a small extra ROM chip, one bit per instruction, on the Skoal board. In addition to these and other built-in rules, the Skoal board adds new CPU instruction prefixes that future software can use to explicitly read from ROM or RAM. The board allows you to extend both the RAM and ROM size to 64 kilobytes.
The name “Skoal” comes from a brand of chewing tobacco.
== References ==
* HP 9825 Repair Part 9 : Skoal board repair (featuring the original designer!), video by CuriousMarc
Category:Implementations
Category:Before_1993
SKVERSE

SKVERSE (SKip and reVERSE) is a programming language that uses skip and reverse to do stuff:
= Stuff =
== Skip ==
Skips a command
 skip
 print "this will not be ran"
== Reverse ==
Reverses the direction of the code
 print "start" #runs at the start
 skip #skips reverse
 reverse #infinite loop v
 print "loop" #runs forever
 reverse #infinite loop ^
 print "end" #never runs
== Skverse ==
Skips a command and reverses the direction of the code
 print "ok" #only ran once
 skverse
== End ==
Ends the program
 skip
 end
 reverse
== Start ==
Starts the program
 end
 start
 skip
 
 reverse
== Line ==
Labels a line + Refers to a line using names
 line 1
 skip line 3
 line 3
== Edit ==
Edits a line that is labeled
 line 1 #ran as print "hello" after line 2
 edit line 1 print "hello"
 reverse
== Run ==
Runs a line that is labeled
 line 1
 edit line 1 print "hello"
 run line 1 #print "hello"
== Line# ==
Refers to a line using 0 based indexing
 line a
 line 1
 line 2
 line 3
 edit line a 2
 edit line 1 10
 edit line 2 20
 edit line 3 30
 print line# (line a) #line 2 so 20
== Group ==
Groups lines
 group line# 2 line# 4 as group1
 skip
 print "this is in group1"
 skip
 print "so is this"
 skip
 print "but not this"
 run group1 #print this is in group1 and so is this
== Reversed? ==
If Reversed 1, else 0
 print reversed #print 0 then 1
 reverse
== Split ==
Split depending on if 0 or 1, if 1, do first jump, else do second jump
 skip
 split reversed line# 4 line# 6
 
 skip
 print "reversed"
 skip
 print "not"
 skip
 
 reverse
SLOBOL

SLOBOL is a joke language created by John Unger Zussman, and is one of the lesser known programming languages. It was described in the Info World article as follows:
:SLOBOL is best known for the speed, or lack of it, of its compiler. Although many compilers allow you to take a coffee break while they compile, SLOBOL compilers allow you to take a trip to Bolivia to pick up the coffee. Forty-three programmers are known to have died of boredom sitting at their terminals while waiting for a SLOBOL program to compile. Weary SLOBOL programmers often turn to a related (but infinitely faster) language, COCAINE.
== Languages inspired by this description ==
*SLOBOL (2005 language)
*SLOBOL (2015 language)
Category:Joke languages
Category: Languages
SLOBOL (2005 language)

SLOBOL is a simple language, designed to fill in another gap in the lesser known programming languages. It is essentially the same as Foobar and Foobaz and Barbaz, oh my!, except for the form that each program is in — a series of SHA-512 hashes.
To convert a Foobar program into a SLOBOL program, just take its SHA-512 hash, then rotate the lines upward, take the hash again, perform another rotation, etc. until you end up back where you started.
The "cat program" in SLOBOL:
 015e64bbf2a429e22c41c40398b47a04
 9f891454580e8ae175a9b4f159d2fe01
 2ec028f86e383f9b45db509d93748ff7
 268bff0da11ed8ba5545793796db4d40
 9dbe93d00141819d5cd527c7d428d04e
 b7ab7384c2cdcf879e07daba0819c76c
 36ca3c7a9d31b7dadb492f4e397e1b6b
 d94bc1fec2a41c2fd95b04915283db41
For anybody who can't stand to look at a one-way hash without seeing what it was made from, they're the hashes of the following:
 ? and 255 and 0, oh my.
 0 and 0 and 0, oh my...
and
 0 and 0 and 0, oh my...
 ? and 255 and 0, oh my.
User:Ihope127 says that a compiler is encouraged to first bruteforce each hash until they all are valid Foobar programs, then check to see if all the results match the hashes. If they don't, bruteforcing should be done all over again, except with these non-matches rejected with the syntax checking.
Category:2005
Category:Joke languages
Category:Finite state automata 
Category:Unimplemented
Category:Low-level
Category:Languages
SLOBOL (2015 language)

SLOBOL is a language created by Tanner Swett in 2015.
A SLOBOL program consists of a grid of characters, representing a Go board of any finite size and shape. The characters may be # (hash, representing a "wall"—a point in the grid that does not correspond to a point on the board), . (period, representing an empty point), X (representing a black stone), or O (representing a white stone).
Execution consists of a game of Go starting with the specified position and obeying the Tromp-Taylor rules. Each player follows the optimal strategy, where "optimal strategy" means that each player always makes the move which results in the highest final score for that player, assuming that the other player follows the optimal strategy. (This definition is recursive but well-founded, as a Go game with superko is guaranteed to halt in time exponential in the number of squares.) If the optimal strategy permits multiple equally good moves, the move which is made is unspecified (a correct implementation may select any of the moves among those which are tied for best).
A naive implementation probably halts in double exponential time in the number of squares.
No significant programs have been created.
Category:Languages