nyuuzyou/wikis huggingface dataset:
Silly Emplosions

This is a new idea of a program language. It is just a idea so it isn't really invented yet. This is a list of the ideas:
* If you leave a variable for too long without assigning a value, the variable will lose its value.
* You can return from a function more than once to return multiple values from the function at the same time.
* Sometimes it skips commands and doesn't do it right the first time so you have to repeat it sometimes.
* If you try to read a value of a variable that isn't set yet, it will continue until a value is assigned, then it will go back and try again what it was trying to do before.
* A return statement will not always know where to return to.
* You can write a program by dragging a stylus across the screen, and if you don't like it, you can try again.
* The source-code needs to have a .EXE extension to confuse people.
** Better version of the idea before: the source-codes need to have the same extensions as the executables, to confuse people.
** Another better version of the idea before: the source-codes need to have the same file names as the executables, and they should be overwritten by the executable files when compiled, to confuse people.
* You have to use floating-point calculations for dealing with strings.
* Large arrays are stored on VHS tapes.
* The program has to compile itself after it has been compiled with the compiler.
** Haha, actually, Java already does that :D
* The program source-code includes control characters like BEL and stuff as parts of variable names.
* Every variable should be immediately deallocated once the data stored in said variable has been read once.
* ] closes an (, } closes [ and ) closes {. Strings start with ' and end with ", or they can start with " and end with ' for the interpreter to automatically convert them to leet.
* Any "if" statement requires at least 14,000 subconditions.
* Array indices start at 0.5 (as a compromise between starting with 0 and starting with 1)
* Programs must be saved as .rtf and written in Wingdings. Every name/keyword is exactly 1 character. If you need more variables, make a namespace. (Anything not in Wingdings is considered a comment.)
** Despite this, the interpreter/compiler only runs on OSes that don't even have Wingdings. So you need two computers to be able to write and run a program.
Category:Ideas
SimPL

SimPL is an esoteric programming language with very simple syntax. SimPL programs are very large because their contents are encoded in unary, there is only one program of each possible length. SimPL is to C as Ellipsis or Unary or A or Lenguage is to Brainfuck. There is also a more compressed representation of SimPL programs, which is equivalent to C. SimPL is defined in the following article:
* Brendon Boldt, "Formulating the Syntactically Simplest Programming Language", (2020-04-01) proceedings of SIGBOVIK 2020 Carnegie Mellon University, Pittsburgh, PA. 
Category:Languages Category:2020 Category:Turing complete
SimPPLe

SimPPLe (Simple Probabilistic Programming Language) is a probabilistic programming language. Most programs written in this language, produce different results every time they're executed. You can only assign random values to variables. Even data inputed by the user will only assign a random value.
==Language Overview==
Command 	Description
int [var] 	declare a new integer and initialize it with random value
flt [var] 	declare a new float and initialize it with random value
add [var] [var2] 	add [var] to [var2] and save the result in [var]
sub [var] [var2] 	subtract [var] of [var2] and save the result in [var]
mul [var] [var2] 	multiplicate [var] by [var2] and save the result in [var]
div [var] [var2] 	divide [var] by [var2] and save the result in [var]
out [var] 	output the value of the variable
chrOut [var] 	output the value of the variable as character
intIn [var] 	set variable to random value between 0 and the userinput
chrIn [var] 	set variable to random value between 0 and ASCII value of the userinput
jmp [var] 	jump to the value of the variable
jmpGtr [var] [var2] 	jump to the greater value or if both values are equal continue execution normally
jmpLss [var] [var2 ]	jump to the lesser value or if both values are equal continue execution normally
end 	end the program
==Examples==
===Output a random number===
 int y
 out y
===Adding to random numbers in user set limit===
 intIn y
 intIn x
 add y x
 out y
===Print random amount of random characters===
 int y
 int x
 chrOut y
 chrOut x
 jmp y
 jmp x
The program execution can also end in an endless loop.
===Endless loop===
 int j
 jmp j
==Implementations==
There is an interpreter written in Python.
Category:Languages Category:Probabilistic Category:Unusable for programming Category:Implemented
Simon says brainfuck

Simon says brainfuck is an esolang created by User:None1,based on brainfuck, the only difference is that each line in the code should begin with "Simon says: "(without quotes, but with space in the end, case sensitive.), otherwise it will be ignored.
==Turing completeness==
Simon says brainfuck is of course Turing complete because brainfuck is.
==Example Programs==
===Cat Program===
 Simon says: +[,.]
Note that the space in the middle is MANDATORY.
===Hello World===
Simon says: +++++++++[>++++++++<-]>.>++++++++++
Simon says: [>++++++++++<-]>+.+++++++..+++.>++++
Simon says: [>++++++++<-]>.<<<<+++++++++++++++.>>.+++.------.--------.
==Interpreters==
===Python===
def bf(code):
 tape=[0]*1000000
 s1=[]
 s2=[]
 matches={}
 for i,j in enumerate(code):
 if j=='[':
 s1.append(i)
 if j==']':
 m=s1.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='+':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='-':
 tape[p]=(tape[p]-1)%256
 if code[cp]==',':
 tape[p]=ord(sys.stdin.read(1))%256
 if code[cp]=='.':
 print(chr(tape[p]),end=)
 if code[cp]=='<':
 p-=1
 if code[cp]=='>':
 p+=1
 if code[cp]=='[':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]==']':
 if tape[p]:
 cp=matches[cp]
 cp+=1
d=""
while 1:
 try:
 c=input()
 except:
 break
 if c.startswith('Simon says: '):
 d+=c
bf(d)
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Languages
Category:Joke languages
Category:Turing complete
Category:Turing tarpits
Category:Cell-based
Category:Low-level
Category:Implemented
SimpIe progranning language

SimpIe progranning language is a WIP eso-lang made by User:Zenenbee that is both based off of Beatnik and also Multiline
Command	Description
00 	Adds the value as a ASCII code to the stack
01 	Prints the current stack
02 	Clears the stack
03 	Moves the top item in the stack down the value
04 	Pops the top number off the stack
05 	Gets a input and adds first letter to stack
06 	Swaps top 2 stack values
07 	Add the top 2 values
08 	Subtracts the top 2 values
09 	Copies the top value
10 	Moves back some spots if top stack value == 0
11 	Moves forward some spots if top stack value == 0
f0 	Crashes the program
f1 	Dedicated dummy code
==Examples==
===Hello, World!===
00 48
00 65
00 6c
00 6c
00 6f
00 20
00 77
00 6f
00 72
00 6c
00 64
00 21
01 00
==External resources==
===Interpreters in Python===
* SimpIe progranning Ianguage is the main interpreter created by User:Zenenbee
Category:Languages Category:Implemented Category:2020
Simplack

Simplack is a simple, stack-based language created by User:Saka.
Simplack is designed to be easy to learn.
== Basics ==
In Simplack, only integers can be stored in the stack, although they can be outputted as ASCII characters.
Each instruction is on a separate line.
Comments are any line that start with #
== Instructions ==
Certain arguments can use values from other items in the stack by using $n where n is the index that the value will be taken from. These arguments are marked by an asterisk (*) after them.
Instruction 	Description
push n 	Push the integer n to the top of the stack.
pop n 	Pop/remove item at index n.
increase i n* 	Increase integer at index i by n
set i n* 	Set the integer at index i to n
if i n* goto l	If the integer at index i is n, go to line l, otherwise, carry on.
goto n 	Go to line n.
output i t 	Output item at index i as either ASCII (t = a) or an integer (t = i).
input t 	Get either ASCII (t = a) or integer (t = i) input and push it to top. If a string is inputted, each character will get pushed one by one, not as the whole string.
exit 	End the program.
== Examples ==
Here are some examples:
===Truth Machine===
 input i
 if 0 1 goto 4
 output 0 i
 exit
 output 0 i
 push 1
 goto 4
===CAT===
 input a
 push 0
 output 0 a
 pop 0
 if 0 0 goto 6
 goto 2
 exit
===Hello, World!===
 push 72
 push 101
 push 108
 push 108
 push 111
 push 44
 push 32
 push 87
 push 111
 push 114
 push 108
 push 100
 push 33
 push 0
 output 0 a
 pop 0
 if 0 0 goto 18
 goto 14
 exit
===Square of Input===
 #Calculates the square of whatever
 input i
 push 0
 push 0
 increase 2 $0
 increase 1 1
 if 1 $0 goto 8
 goto 4
 output 2 i
 
===Fibonacci===
 push 0
 push 1
 push 0
 push 0
 push 10
 set 3 $0
 increase 3 $1
 set 2 $3
 set 0 $1
 set 1 $2
 output 3 i
 output 4 a
 goto 5
== Interpreters ==
=== Python ===
Available on GitHub
== Extension ==
There is an simplack extension, with more functionalities called Complack
Category:Languages
Category:Stack-based
Category:2018
Category:Implemented
SimpleBBQ

SimpleBBQ is an esolang under construction by DanielE (talk) 13:59, 27 March 2022 (UTC) that is... well, pretty simple. You have a small barbecue that can hold only one hamburger, one little piece of beef and a nugget.
SimpleBBQ has some basic I/O commands and arithmetic. It uses letters as code: lower- and uppercase B and Q, and C. One command consists of an amount of B’s or Q’s.
 Caption text
Header text	Header text	Header text
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Example 	Example 	Example
Still a page under construction.
==External resources==
* Official SimpleBBQ Interpreter Made by Creator
Category:Languages Category:Unknown computational class
SimpleCalc

SimpleCalc is an esolang by User:Ohnoitsnoah that functions as a simple-to-read basic 4 function calculator. This is meant to be as human-readable as possible. It is also meant to be used only in a REPL.
 Instruction Set
Command	Function
add 	Adds the number before with the number after
minus 	Subtracts the number before with the number after
times 	Multiplies the number before with the number after
div 	Divides the number before with the number after
equals 	Prints the output of your equation
== Example ==
repl> 3 times 4 div 2 equals
[1]>9
Category:Languages
SimpleScript

SimpleScript is an esoteric programming language invented by User:A, similar in many aspects to brainfuck, but regarding its architecture operating on a stack and a single register, while the command set is extended to accommodate for these variations.
==Architecture==
A program in this language is offered access to two memory storages: a stack of infinite size intended to store byte values, and a register maintaining an unbounded integer. Both data conditories partake of input and output capacities, and their interrelations may be availed for computations.
==Commands==
SimpleScript's commands embrace strings, instructions composed of a single character, and an iteration facility.
Command	Description
"chars"	Pushes the ASCII character codes of the chars in the string unto the stack, in the order of their appearance.
a 	Empties the stack while outputting its elements as ASCII characters, in the order of their popping.
b 	Prompts the user for a character and stores its ASCII code in the register.
c 	Prompts the user for a string and pushes its characters' ASCII codes unto the stack, from left to right.
d 	Pops a value from the stack and writes it to the register.
e 	Prints the content of the register as a number.
f 	Prints the content of the register as the associated ASCII character.
g 	Pushes the content of the register to the stack.
h 	Pops a value from the stack and increments the register by this value.
i 	Pops a value from the stack and decrements the register by this value.
[ 	While the register equals 0, the code betwixt [ and either the matching ] or, if not present, the end of the program, is executed. If the register does not equal 0, the enclosed code section is skipped.
] 	Terminates a code section to repeat started by a [.
==Examples==
===Hello, world!===
The following program prints “Hello, World!” to the standard output:
 "!dlroW ,olleH"a
===Cat program===
An infinitely repeating cat program may be implemented as such:
 bf[bf]
===Truth-machine===
A truth-machine is implemented in the following:
 "0" b i [e] e
==Interpreter==
* Common Lisp implementation of the SimpleScript programming language.
Category:Languages
Category:2018
Category:Implemented
Category:Low-level
Category:Stack-based
Category:Brainfuck derivatives
Simple Smurf

Simple Smurf is a very simple language invented by User:A.
It initializes the tack with input, in the end pop a string and output, and pop another to execute as a program.
j	Pop 2 variable names and join their values.
s	splits a string into a head and a tail and pushes them onto the stack (tail first)
"	next character is added to the string buffer. This ends with '?' .
p	pops two strings from the stack, and sets the variable with the name specified by the first string to the value specified by the second string.
q	quotes the string on the top.
Simplefunge

Simplefunge is an esoteric 2d language created by User:CrazyM4n in 2014.
Simplefunge was originally going to be a mash of Brainfuck and Befunge, but ended up just being a simpler language similar to Befunge.
The GitHub page is here, and contains a quick reference and interpreter for the language.
== Syntax ==
The code in Simplefunge is executed starting at the top left of the file. It follows the direction of the arrows and executes any command along the way. The available commands are:
* < = move cursor left until a direction change command is encountered
* > = move cursor right until a direction change command is encountered
* ^ = move cursor up until a direction change command is encountered
* v = move cursor down until a direction change command is encountered
* H = move cursor right if top of stack is >0 or left otherwise
* V = move cursor up if top of stack is >0 or down otherwise
* I = input character
note: characters get converted to integers on the stack
note: this is standard style, it just takes the latest char of all the input to the program
* i = input integer
* O = output character
* o = output integer
* # = output stack for debugging purposes
* n = output newline
* 0-9 = push number to top of stack
* + = add numbers on top of stack
* - = subtract numbers on top of stack, going backwards, as in "top - second to top"
* * = multiply numbers on top of stack
* / = divide numbers on top of stack, going backwards, as in "top / second to top", and places the result on the stack with the top being "divisor", then the next being "remainder"
* ` = pop top of stack
* ! = duplicate top of stack
* & = switch the top two values on the stack
* | = pop the top of the stack, then move the value from that index to the top - not counting the popped element
* . = pop the top of the stack, then move the next top value to that index - not counting the popped element
note: the top of the stack is index 0
* (space) = continue direction of cursor
* @ = end of program
== Example Programs == 
As far as I know, this language is completely turing-complete, due to, in the most part, the | operator. Therefore, any program is able to be created in Simplefunge. A few good examples are, though:
=== One character cat ===
 >IO@
=== Truth-machine ===
>ivv
 o
 ^
 >V
 0
 o
 @
=== Fibonacci sequence ===
>1>!2|+onv
 ^ <
Category:2014
Category:Two-dimensional_languages
Category:Implemented
Category:Languages
Category:Stack-based
Category:Turing complete
Simpler

Simpler is an esolang by User:Yeetb01. It is a stack-based concatenative language.
== What stuff does ==
* 0-f Push hexadecimal digit onto stack
* add Stack = a b, Does b+a
* sub Stack = a b, Does b-a
* mul Stack = a b, Does b*a
* div Stack = a b, Does b/a
* mod Stack = a b, Does b%a
* squ Square top of stack
* cub Cube top of stack
* pow Stack = a b, Does b^a
* sqr Square root top of stack
* cbr Cube root top of stack
* nrt Stack = a b, Does bthroot(a)
* dup Duplicates top of stack
* inc Increments top of stack
* dec Decrements top of stack
* inn Input number on top of stack
* ina Input ASCII on top of stack
* prn Print value
* pra Print ASCII value
* tgl Toggle between stack 1 and stack 2
* grt Stack = a b, If b > a then true else false
* lst Stack = a b, If b < a then true else false
* eql Stack = a b, If b = a then true else false
* if[expression][ If expression is true, do these commands until ] else do following es[
* es[ Defined in if[
* dw[expression][ Do while expression is true until ] and repeat until expression is false.
== Syntax ==
Line breaks or spaces in between the commands and the last brackets '[' and ']' in if[ and dw[
Like this:
5 4 mul f 4 add if[eql][
16 7 mul dup pra 2 add a squ 5 add pra b a mul dup pra 6 add pra
]
prints
"print"
SimpliVode

SimpliVode (Originally SimpleCodeV) is a one-instruction language that has no branching, operators or comparisons. It only has one command:
 mem <memory address> <value to write>
where <memory address> must be a valid memory address and <value to write> must be a hexadecimal number with a length equal to that of the memory address's length. 
== Compiling to SimpliVode ==
Any SimpliVode compiler must be capable of running the language that is being compiled to SimpliVode, and monitoring the memory of the device that runs it. From then on, compiling is as simple as converting each memory state change to a SimpliVode line! In conclusion, SimpliVode is a fast and easy to compile language.
Category:Languages Category:OISC
Simplified Circuit Diagram

Simplified Circuit Diagram is a language created by user:ps4star and is a 1-dimensional simplified version of the Circuit Diagram language.
== Syntax and Commands ==
=== Syntax ===
Simplified Circuit Diagram uses an Assembly-like syntax where the command name and parameters are separated by spaces. A typical program should look like this:
 XOR 1 2
 AND 1 3
=== Commands ===
Name 	Effect
EXEC 	Executes a file as code, then jumps back to the file it was called from. See *NOTE 1 below.
WIRES 	Defines the number of wires the circuit uses.
OUTPUT-MODE	Defines how detailed the output of the program is. See *NOTE 2 below.
SPLIT 	Splits a wire into two wires with the same value as the original wire. See *NOTE 3 below.
AND 	Sends two wires through an AND gate.
OR 	Sends two wires through an OR gate.
XOR 	Sends two wires through an XOR gate.
NOR 	Sends two wires through a NOR gate.
NAND 	Sends two wires through a NAND gate.
XNOR 	Sends two wires through an XNOR gate.
NOT 	Sends a wire through a NOT gate.
*NOTE 1: The interpreter will always start reading from the file "MAIN.cdl". The EXEC function can be called in the MAIN.cdl file to change the file it runs from the main to something else.
*NOTE 2: If the mode is 1 (which is the default value if no value is set), the program only outputs the values of the wires. If the mode is 2, the program also outputs the wire dictionary after every instruction. If the mode is 3, the program outputs each command and the change in the wires after the command is run, as well as the values of the wires.
*NOTE 3: The new wire created from the SPLIT will be named the highest wire ever assigned plus one. So if you call WIRES 3 then SPLIT a wire, you now have 4 wires: 1, 2, 3, 4. So the name of the wire that is created from the first SPLIT instruction will be Input_Wires + 1. Then the second SPLIT instruction you call will be have the name of Input_Wires + 2, and so on.
== Examples ==
=== Full Adder Circuit ===
WIRES 3
OUTPUT-MODE 3
SPLIT 1
SPLIT 2
SPLIT 3
XOR 1 2
SPLIT 1
XOR 1 3
AND 6 7
AND 4 5
OR 4 6
Adds the 3 input wires together.
=== Full Subtractor Circuit ===
WIRES 3
OUTPUT-MODE 3
SPLIT 1
SPLIT 2
SPLIT 3
XOR 2 3
SPLIT 2
NOT 7
AND 4 7
NOT 5
AND 5 6
XOR 1 2
OR 4 5
Subtracts the first wire by the second wire; the third wire is the carry value.
== Interpreters/Compilers ==
Python Interpreter by ps4star.
Category:Languages Category:Implemented Category:Unknown computational class
Simplified Emmental

Simplified Emmental is a self-modifying language. It is stack-based.
==Instruction set==
Instruction	Description
# 	Push NUL (ASCII 0) onto stack.
0..9 	Pop symbol, multiply by 10, add 0..9 respectively, push back on.
. 	Pop symbol from the stack and output it.
==External resources==
* An interpreter on GitHub written in C++
== Interpreter ==
 #!/usr/bin/ruby
 eval 'm=[];c=0;'+ARGF.read.gsub(/[0-9#.]/,Hash.new{|_, k|"c=c*10+#{k};"}.merge({'#'=>'m<<c;c=0;','.'=>'putc c;c=m.pop;'}))
Category:Languages
Category:Self-modifying
Category:Stack-based
Category:2018
Category:Total
Category:Unusable for programming
Category:Implemented
Single Four

Single Four is an esoteric programming language created by Starla Insigna. It was designed to be extremely difficult (if not impossible) to program with.
== Instructions ==
Single Four has only three legal instructions.
* - - Comment character. Anything following the comment character is ignored.
* (Space) - Separation character.
* 4 - Everything else.
A line of Single Four code consists of a function call and a space-delimited list of arguments. Functions in Single Four are all referenced by a number and all variables are number-referenced as well. However, the only number you are allowed to use is 4 (44, 444 and so on are also allowed) and neither the function IDs nor the variable IDs follow that rule.
This makes programming with Single Four a huge challenge as the only functions immediately available to you are 4 and 44. However, with some thought, a simple program can be written using only those two functions, because function 44 means "call the function whose ID is stored in the variable whose ID is the first argument with the argument after the first argument".
There are 21 defined functions in the Single Four language. There is a link to a list of functions below, in the External resources section.
An example of a line of Single Four code is as follows. The following code divides (function 4) 4 by 4 (the first two arguments) and store it in variable 4 (the last argument):
 4 4 4 4
Every Single Four program must be terminated by calling function 0. However, you are only allowed to use 4 and 44. This is how you terminate a Single Four program only using the legal instructions:
 4 4 44 44 - Divide four by forty-four (which, in integer division, is zero) and store it in variable 44
 44 44 - Call the function whose ID is in variable forty-four, in this case zero, so terminate the program
=== Example ===
The only known program written in Single Four is the Hello World program. This program is 485 lines of code long, so it will not be reproduced here, instead, a link to it is provided below in the External resources section.
== External resources ==
* Single Four Function List
* Hello World in Single Four
* Single Four Interpreter for Linux
* Single Four Interpreter for Windows
Category:Languages
Category:Unusable for programming
Category:Implemented
Sipes

Sipes is an esoteric programming language found in an old Notebook created by User:Buckets in 2019, 
User:Buckets has Completely forgotten the Instructions and Commands, The only Insight was It was created April 13th 2019, A note saying
'The interpretir can be 33 toothpicks, I think.' And yes, 'interpretir' was spelled that way and The final Insight was about the Instructions 'Pri Inp check <<num =s if=goto nextnum'.
"Hello, World!" Program:
 01001000100
 01100101100
 01101100100
 01101100100
 01101111100
 00101100100
 00100000100
 01010111100
 01101111100
 01110010100
 01101100100
 01100100100
 00100001100
Truth-machine Program:
 00000000010
 00000000001
 00000111000
 00110000100
 00110000001
 00001010000
 00110001100
 00110001001
 00000111000
 00000000000
These two programs are the only programs shown in the notebook for this esolang.
Category:Languages
Category:2019
Category:Stubs