nyuuzyou/wikis huggingface dataset:
Sir. Cut

Sir. Cut is an esoteric programming language created by poiuy_qwert. The name is actually a play on the word Circuit, which is what the language is based on. You have wires, current, logic gates, and I/O to create programs.
==Commands==
Command	Name 	Description
[ 	Battery 	At the beginning of the program, a wire with current 1 starts here. The higher a battery is in the program, the more priority its wire gets.
] 	Empty Battery 	The same as [, but the current starts as 0.
@ 	Light Bulb 	Pushes the current onto the output stack. Once the output stack reaches 8 values, it is output as a character.
/ 	Switch 	Gets a character and puts its binary representation into the input memory.
+ 	Get Input 	Pops the top 0/1 off the input memory and sets the current to it.
! 	Not Gate 	Performs a logical not on the current.
% 	Or Gate 	Performs a logical or on the currents of the wires coming from the left and top, then continues toward the right.
& 	And Gate 	Same as % but using a logical and.
X 	Xor Gate 	Same as % but using a logical exclusive or.
0/1 	Set Current 	Sets the current to 0 or 1.
= 	Split wire 	Splits a horizontal wire into 2 wires with the same current, one above and one below. The wire above gets priority over the wire below.
# 	Ground 	Stops the current wire.
~ 	Repeat 	If the current is 1, its flow will jump back to the current wire's inital battery.
- 	Horizontal Wire	A path for the current to follow. If a vertical wire hits a horizontal one, its current continues toward the right.
 	Vertical Wire 	A path for the current to follow. If a horizontal wire hits a vertical wire, its current continues upward unless there is no wire above, in which case it continues downward.
< 	Right Bridge 	When the current is heading toward the right, this skips the next command, as if the wire passes over it.
v 	Up Bridge 	Same as < but for current heading upward.
^ 	Down Bridge 	Same as < but for current heading downward.
==Semantics==
When the program starts, the interpreter looks throught every line of the code finding every ] and [. The ones found first are given more priority than the ones behind them. Program flow then moves the current to the next command on the right. Program flow can only go upward, downward, and toward the right. The commands -, |, =, <, v, and ^ are considered to execute with no loss of time. What that means is that in this program:
 ]--@
 [-@
even though the top line has a longer wire, its @ executes first because it has a higher priority, being the first line.
==Examples==
===Hello, World!===
This program will output "Hello, World!" to the screen, then stop.
 ]@!@!@@!@!@@@@!@@!@@!@!@!@!@!@@!@!@@!@@@!@@!@!@@!@@@!@@!@!@@@@!@@!@!@!@@!@@@@!@!@@@@@@!@!@!@!@!@@@!@!@@!@!@@@@!@!@@@!@@!@!@@!@@!@!@@!@@@!@@!@@!@!@@@@!@!@@@@!@#
===Cat===
This program takes its input and outputs it to the screen, repeating forever.
 ]/+@+@+@+@+@+@+@+@1~
For a more complex program, you can instead do it like this.
 -/+@#
 -=
 |-+@1~
 -=-+@#
 |-=
 | -+@#
 ]=
 | -+@#
 |-=
 -=-+@#
 |-+@#
 -=
 -+@#
Category:Languages
Category:Unknown computational class
Category:Two-dimensional languages
Category:Unimplemented
Category:2006
Sirc

== Sirc ==
Sirc (single register computer) as in name it only has a single register, also it doesnt allow any immediate values 
=== Architecture ===
* The CPU has a single register (acc).
* RAM stores both the program and data.
* No immediate values are allowed; all operations depend on values in `acc` or RAM.
* Programs begin execution at RAM address `0`.
=== Memory ===
* RAM contains both instructions and data.
* RAM is limited to 65536 adresses
* Each RAM adress can hold 2^16 (unsigned)
=== Instruction Set ===
Sirc has a minimal set of instructions,
* `hlt` halts the program
* `lac` load given ram adress into acc
* `sac` load acc into given ram adress
* `jgz` jmp to given adress or label (in assembler) if acc > 0
* `jez` jmp to given adress or label (in assembler) if acc == 0
* `jmp` jmp to given adress or label (in assembler) no condition
* `add` adds given ram adress value into acc
* `sub` subtract given ram adress value from acc
=== Example Programs ===
==== Increment a acc ====
This program increments the value of acc.
 lac 0x01 ; load ram adress 0x01 value into acc (this does nothing other than setting ram adress 0x01 value to 1)
 add 0x01 ; 0x01 is now 1 so we add it into acc
=== implementations ===
 sadly there is no implementation right now but i am developing in python
Category:Turing tarpits 
Category:Low-level 
Category:unimplemented
Category:Languages
Category:2024
Sitelen ilo

sitelen ilo is a programming language based on toki pona (made with the knowledge of toki pi ilo nanpa and sona). It was made by jan Gamecuber.
==Formatting==
Newlines mark the next command (no semicolons) and blocks are indented. Comments start with namako.
==Commands==
===Variable assign===
This is done with VarName li VarType VarValue 
===Data Types===
There are four types. These are nanpa (double), nimi (string), kulupu (list) and lupa (null).
===Control Flow Statements===
If-Then statements are made using Condition la ni and a block on the next line that is only executed if the condition is true.
Labels are made with ma ni li LabelName and gone to with tawa LabelName 
===I/O and libraries===
To get input, use sina Prompt and to print use toki Value . To import a library, use lukin LibraryName 
===Functions===
Defining a function is done with sin Name pi Param1, Param2 ... and a block storing the code. Calling is done with pali Name pi Param1, Param2 ... . Return statements are sitelen ReturnValue .
===Structs===
A struct is started with poki StructName li ni: and properties are written to within the definition as a regular variable assignment. To access a property, name the property and then name the struct it is a part of. 
===Extra details===
Math and conditions are handled by jan Emalan's numbering system, but with taso as bitwise nand. Lists work with indices like in python, but to append or insert to a list, you just use the index where you want it to go.
==Prebuilt functions==
===suli===
With 1 arg, suli takes the length of that arg in bits (or for lists, list entries) (null is 1).
With 2 args, suli returns the larger/longer.
===nasa===
With no args, nasa returns a random float from 0-1.
With 1 arg, nasa returns a random element or byte of the arg.
With 2 args, nasa is random.randrange() from python.
Category:Pseudonatural
Category:Languages
Category:Thematic
Category:Unimplemented
Category:Turing complete
Category:Functional paradigm
Category:2022
Six instruction language :)

this is my first one btw 
Six instruction language is a language that has 6 instructions. An input stream is absent.
It has 3 registers and each are stored as a number from 0 to 15.
Register 3 is the output of the program.
==Instructions==
The following instructions are available. Please heed that the first register is named r1, the second r2, and the third r3.
 Six instruction language :)'s instructions:
Instruction	What it does
1 	Set r1 to n
2 	Set r2 to n
3 	Set r3 to r1+r2
4 	Wipe r3
5 	Wipe r1 and r2
6 	Invert r1 (set r1 to 15-r)
To pass an argument to the commands 1 and 2, you proceed the command with the following encoder table:
 encoding
argument	input
0 	a
1 	b
2 	c
3 	q
4 	w
5 	e
6 	d
7 	f
8 	g
9 	r
10 	t
11 	y
12 	h
13 	i
14 	j
15 	u
So 1e means to set r1 to 5.
==Example Programs:==
===Addition===
1+1:
 1b2b3
Output:
 2
because 1+1=2
===State Inversion===
This program sets the value of the first register to five, inverts, and prints it:
 1e63
==Interpreter==
* Common Lisp implementation of the Six instruction language :) programming language.
Category:LanguagesCategory:2022 Category:Total Category:Implemented Category:Unusable for programming Category:Output only
Sixtyfeetunderassembly

Sixtyfeetunderassembly(SFUasm) is a useless esolang created by User:TheMCoder
==== Overview ====
SFUasm has 4 commands
 commands
Command name 	description
OUT <v> 	output the ascii value of v
SET <v> <value> 	sets v to value
IN 	gets input from the user and stores it in input
GET <v> <letter index>	gets letter index from input and stores it in v
The code NEEDS to be stored in 'code.dpasm' so the interpreter can fuction.
SFUasm is very case-sensitive, the commands NEED to be in uppercase.
==== Code ====
there is only a python interpreter
===== python code: =====
 v = 0
 varvals = []
 varnames = []
 code = open("code.dpasm","r").readlines()
 linenum = 0
 printer = ""
 userinput = ""
 for line in code:
 linenum += 1
 #print(line)
 #print(v)
 line = line.strip("\n")
 commands = line.split(" ")
 if commands[0] == "SET":
 if not len(commands) > 3:
 if not commands[2] in varnames:
 varnames.append(commands[2])
 varvals.append(0)
 varvals[varnames.index(commands[2])] = int(commands[1])
 else:
 print("SYNTAX ERROR: Unexpected argument on line",str(linenum))
 elif commands[0] == "OUT":
 if not len(commands) > 2:
 printer += chr(varvals[varnames.index(commands[1])])
 else:
 print("SYNTAX ERROR: Unexpected argument on line",str(linenum))
 elif commands[0] == "IN":
 if not len(commands) > 1:
 userinput = input()
 else:
 print("SYNTAX ERROR: Unexpected argument on line",str(linenum))
 elif commands[0] == "GET":
 if not len(commands) > 3:
 if not commands[1] in varnames:
 varnames.append(commands[1])
 varvals.append(0)
 varvals[varnames.index(commands[1])] = ord(userinput[int(commands[2])])
 else:
 print("SYNTAX ERROR: Unexpected argument on line",str(linenum))
 elif commands[0] == "--":
 pass
 else:
 print(f"ERROR: Unknown command {commands[0]!r} on line {str(linenum)}")
 print(printer)
==See also==
* Sixtyfeetunderassembly+
Category:Languages Category:Joke languages Category:Total Category:Unusable for programming Category:Low-level Category:Implemented
Sixtyfeetunderassembly+

Sixtyfeetunderassembly+ is an extension of Sixtyfeetunderassembly.
== Commands ==
Command |Meaning
-----------------------------------------------------------
OUT |Output <v> as ASCII character.
SET <n> |Set <v> to <n>
IN |Set <v> to user input.
INCREMENT |Increment <v>
DECREMENT |Decrement <v>
WHILE NOT ZERO (<commands>) |While not zero.
== Examples ==
Cat:
IN
WHILE NOT ZERO (OUT IN)
Category:Languages Category:Unusable for programming Category:Low-level
Skastic

Skastic is a visual, functional programming language where source code is contained in image files (.png). Skastic programs contain nodes and edges representing an abstract syntax tree.
Skastic can be seen as a critique of LISP, and really isn't intended to be used by anyone.
==External resources==
Source code and more details here
Category:Languages
Category:Functional paradigm
Category:2017
Category:Two-dimensional languages
Category:Implemented
Category:Non-textual
Category:Turing complete
SkibLang

SkibLang (also stylized as Skiblang or Skib-Lang) or skibidilanguage is a programming language based on gen alpha slang, with inspiration from Lua and JS. SkibLang was designed and first implemented by Alexander Meade.
== Examples ==
=== FizzBuzz ===
 skibidi map(values, fn) {
 newValues = []
 ohio "
 for i, v in ipairs(values) do 
 newValues[#newValues+1] = fn(v)
 end
 "
 lowtaperfade newValues
 }
 skibidi fizzBuzz(n) {
 sus (n % 3 == 0 && n % 5 == 0) lowtaperfade "fizzbuzz"
 sus (n % 5 == 0) lowtaperfade "buzz"
 sus (n % 3 == 0 ) lowtaperfade "fizz"
 lowtaperfade n
 }
 [1,2,3,4,5] :3 map(fizzBuzz) :3 map(skibidi _(n) {print(n)})
Category:2024
Category:Turing complete
Category:Joke languages
Category:Implemented
Skibidi Toilet

Skibidi Toilet is a esolang made by Mihai Popa, based on Gen Alpha slang.
== Commands ==
 Command table
Command 	Meaning 	Example (in Batch)
Toilet "something" 	Prints a text string 	echo something
Skibidi {x} 	Gives user input 	set /p x=
Toilet {x} 	Prints a variable 	echo %x%
Start Skibidi {x} {expression}	Starts a while loop 	See the "While loop in Batch" section
End Skibidi 	Ends a while loop 	See the "While loop in Batch" section
Set Toilet {x} To {something} 	Sets a variable to a value 	set x=something
Set Color to Skibidi 	Changes the console color to Matrix 	color 0a
Set Color to Default 	Changes the console color to default	color 07
Skibidi Toilet 	Prints "Skibidi Toilet" 	echo Skibidi Toilet
Start Skibidi Loop 	Starts a loop 	See the "Loop in Batch" section
End Skibidi Loop 	Ends a loop 	See the "Loop in Batch" section
== While loop in Batch ==
Batch doesn't have a standalone "while" command but you can do with this example:
@echo off
set x=1 
:loop
if %x% LEQ 10 (
 echo %x%
 set /a x=%x%+1
 goto loop
)
== Loop in Batch ==
Here's a demo of a loop in Batch, a Truth Machine (also posted on the Truth Machine page!)
@echo off
set /p truth=Your input? 
if %truth% EQU 1 goto loop
echo 0
pause>nul
exit
:loop
echo 1
goto loop
== Notes ==
# "{expression}" means is a expression placeholder. For example "Start Skibidi {x} {expression}" means for like "Start Skibidi {x} = 5"
# "{something}" means is a text placeholder. For example "Set Toilet {x} To {something}" means for like "Set Toilet {x} To "Hello!""
# Variables are enclosed in curly brackets, {like so!}
== Examples ==
=== Hello, world! ===
Toilet "Hello, world!"
=== Cat ===
Skibidi {cat}
Toilet {cat}
=== Truth Machine ===
Skibidi {truth}
Toilet "0"
Start Skibidi {truth} = 1
Start Skibidi Loop
Toilet "1"
End Skibidi Loop
End Skibidi
=== XKCD Random Number ===
Toilet "4"
Category:2024
Category:Languages
Category:Pseudonatural
Category:Unimplemented
Category:Joke languages
Skiforth

Skiforth is a SK-calculus based Forth discovered by User:Orby in April 2020.
=Definitions=
S and K are combinators. If x and y are combinators, then x y ` is a combinator.
# z y x S ` ` ` is rewritten to z y ` z x ` `
# y x K ` ` is rewritten to x
=Words=
All words must be separated by whitespace. All words are case insensitive. Skiforth uses post-fix notation. There are 10 built-in words including the ability to define new ones:
# S pushes the S combinator onto the stack.
# K pushes the K combinator onto the stack.
# ` applies the first combinator on the stack to the second combinator on the stack.
# : begins a word definition.
# ; ends a word definition.
# . pops the first combinator off the stack and prints it.
# ( begins a comment.
# ) ends a comment.
# include file includes a file.
# list lists the content of the dictionary.
# bye exits the interpreter.
=Examples=
The I combinator (SKK) is not a built-in command. We can define it by typing
: I K K S ` ` ;
ok
The first token after : is the name of the word. All subsequent tokens until ; compose the body of the word. Let's look at what we created
I .
K K S ` ` ok
We can apply the I combinator to itself and print the result by typing
I I ` .
K K S ` ` ok
We can also redefine built-in commands
: S K S ` ` ;
ok
And redefine commands we've already defined recursively
: S K S ` ` ;
ok
: S K S ` ` ;
ok
S .
K K S ` `
ok
=See also=
* repository for official Skiforth interpreter.
* Bootable ISO which contains the Skiforth OS.
* Unlambda is similar but uses prefix notation.
Category:Languages Category:Stack-based Category:Functional paradigm Category:2020
Skim machine

Skim machine is a language invented by User:A that is a trivial substitution of the Minsky machine.
==Syntax==
Skim machine programs are divided into lines of operations, with each non-empty line entailing a single instruction. Such an operative unit starts with the command name, followed by an accumulator identifier, and optionally concludes utilizing a comma-separated target line number.
Accumulator identifiers comprehend at least one character, being compositions of alphanumeric constituents or the underscore (_).
The following furnishes an Extended Backus-Naur Form (EBNF) description of the language:
 program := [ linebreaks ]
 , [ programLine ]
 , { linebreaks , programLine }
 , [ linebreaks ]
 ;
 programLine := emptyLine | commandLine ;
 commandLine := optionalSpaces
 , ( incInstruction | jzdecInstruction )
 , optionalSpaces
 ;
 emptyLine := optionalSpaces ;
 incInstruction := "INC" , mandatorySpaces , accumulatorName ;
 jzdecInstruction := "JZDEC"
 , mandatorySpaces
 , accumulatorName
 , argumentSeparator
 , integer
 ;
 accumulatorName := nameCharacter , { nameCharacter } ;
 nameCharacter := letter | digit | "_" ;
 letter := "a" | ... | "z" | "A" | ... | "Z" ;
 integer := [ "+" | "-" ] , digit , { digit } ;
 digit := "0" | "1" | "2" | "3" | "4"
 | "5" | "6" | "7" | "8" | "9"
 ;
 linebreaks := linebreak , { linebreak } ;
 linebreak := "\n" ;
 argumentSeparator := optionalSpaces , "," , optionalSpaces ;
 optionalSpaces := { space } ;
 mandatorySpaces := space , { space } ;
 space := " " | "\t" ;
==Commands==
Only two types of operations are employed in the language: INC, which increments an accumulator, and JZDEC, combining in it the potential for decrementing an accumulator or jumping to another line based on its value.
An aperçu shall educate about the available instructions:
Command 	Description
INC a 	Increment the accumulator a by one and proceed to the next instruction.
JZDEC a, b	If the value of the accumulator a equals zero, jump to the line indexed with the zero-based number b. Otherwise decrement a by one.
==Computational class==
It is Turing-complete with at least 3 accumulators, as a 3-accumulator Skim machine can compile to the Minsky machine. (However, a minimization of the number of accumulators is encouraged.)
* INC a, b
INC a
JZDEC c, b
* JZDEC a, b, d
JZDEC a, b
JZDEC c, d
==Examples==
===Adder===
The following program adds the two numbers 2 and 4 and stores the sum in the augend accumulator:
 INC augend
 INC augend
 INC addend
 INC addend
 INC addend
 INC addend
 JZDEC skip, 8
 INC augend
 JZDEC addend, 10
 JZDEC return, 7
==Interpreter==
* Common Lisp implementation of the Skim machine programming language.
==See also==
* Minsky machine
Category:Languages
Category:2019
Category:Implemented
Category:Turing complete
Category:Turing tarpits
Skound

Skound is a minimalistic esoteric programming language created by User:TriMill in 2019. It uses 8 instructions, each of which is a single character. It was created to be easy to interpret but hard to program in.
==Overview==
There are two places to store data in Skound, the accumulator and the stack. The accumulator is initialized to 0, and the stack is initialized empty. The only I/O available is numeric, there is no way to read or print text.
There are 8 instructions:
* + increments the accumulator
* - decrements the accumulator
* 0 sets the accumulator to 0
* V pushes the accumulator to the stack
* ^ pops the stack to the accumulator, or halts execution if the stack is empty
* # skips to the character after the following # character if the accumulator is positive, otherwise execution continues as if it was a NOP
* I inputs a number to the accumulator
* O prints the value of the accumulator
All other characters are ignored.
Once the program reaches the end it wraps back to the beginning(i.e. runs inside an infinite loop), and the last # in the program skips back to the first one.
==Example programs==
===Cat===
IO
This version runs forever and must be stopped manually.
IO#^#
This version stops once the input is less than or equal to zero.
 0#IO0#^# 
This version stops after outputting the input.
===Looping counter===
+O
===Infinite loop===
Since the program counter loops at the end of a program, this generates an infinite loop.
===Truth machine===
 I+V0
 #^-V#
 O^^
 #^-V#
 0+O++V0
 #^-V#
=== Hello World ===
0#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++O0+++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++O0++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++O0+++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++O0+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++O0+++++++++++++++++++++++++++++++++++++++++
+++O0++++++++++++++++++++++++++++++++O0++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++O0++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++O0+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++O0++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++O0+++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++O0+++++++++++++++++++++++++++++++++O0#^#
 Note: Auto-generated by a python program -- prints the ascii value of each char as there is no character output 
==Implementations==
Interpreter in Python
==Computational class==
The computational class of Skound has not yet been determined. 
Category:Languages
Category:2019
Category:Stack-based
Category:Unknown computational class
Category:Implemented
Slander

Slander is a programming language in which you write programs in two dimensions. Programs take the form of a route that autonomous craft must take to safely land on a planetoid. craft are represented in code as the letter S. The route it takes to the landing pad is a source program. Source is divided into blocks that are one character in size. The language was created by User:PixelatedStarfish in 2022 in response to a comment to "do slander slander" for the next installment of TheSTEMGamer's youtube series on programming language slander, which is actually a series of truthful roasts.
===Piloting===
A ship is directed by a command, and moves in a direction until landing or redirecting. A ship stores one byte in the range of 0 to 255 called battery. Multiple ships are allowed, for concurrent programming and (maybe) Turing completeness. When two ships overlap, they exchange battery.
Changing directions reduces battery by 1, and a ship with no battery cannot change direction. A ship starts with 50 battery unless it is an escape pod. Note that a ship has a maximum capacity of 255, battery goes no higher.
Ships move simultaneously on a global ticker. They move at the rate of one cell per tick. If two ships land at the same tick, output occurs from left to right.
===Commands===
 S : program start, S spaceship.
 = : ship can land here. Output battery as char.
 X : hostile ground that destroys a ship.
 r : go right and decrement battery by 1.
 l : go left and decrement battery by 1.
 d : go down, decrement battery by 1.
 u : go up, decrement battery by 1.
 * : Star! Ship battery increments by 10.
 ~ : Galaxy! If the ship has battery it will reverse direction, decrementing battery.
 $ : Quasar! The ship drops an escape pod that takes floor of half the battery.
 ? : UFO! Battery is set to input.
 # : Nova! Set battery to a random amount.
All other characters are comments
===The Source Field===
Blocks are set on a coordinate plane of (X, Y) tuples.
Block (0,0) is the top left block. (1,0) is right adjacent and (0,1) is down adjacent. The source field is sized according to the number of characters in the source file and the location of border commands.
Going up decreases Y. Going down increases Y. Going left decreases X. Going right increases X.
===Exchanging===
After an exchange, each ship has the average battery of all exchanging ships.
Exchanges happen at overlap.
Category:2022
Category:Languages
Category:Thematic
Category:Concurrent programming
Category:Unknown computational class