nyuuzyou/wikis huggingface dataset:
Swirly

Swirly is a forth derivative with static types, which compiles to uxntal, created by isabelle cedar. It uses state switching to switch between a text, type, compile, and code stack.
==States==
A swirly program starts in the ~text state. To change states, write ~[state]. The available states are
- ~text
- ~type
- ~code
- ~compile
The text state is contains text, and is ignored by the compiler. It can be used to create comments in the literate programming style.
==Types==
- # denotes a 16-bit unsigned integer, or short
- ' denotes an 8-bit unsigned integer, or char
- x [ denotes a pointer to x, which is a 16 bit address
- x -> y denotes a function taking x and returning y. x and y can both be more than one type, if the function takes multiple arguments or returns multiple values, or omitted if there are no arguments or return values.
==Some Words==
A non-exhaustive list of the words in swirly:
word 	description
#a #b -- #a+b 	
#a #b -- #a-#b	
* 	#a #b -- #a*#b
/ 	#a #b -- #a÷b
#2' 	convert a # to a '
'2# 	convert a ' to a #
device-out 	( a# b' -- ) write # a to a device b
device-out' 	( a' b' -- ) write ' a to a device b
==Examples==
====Set the screen size====
 8 3 * Screen/width 8 3 * Screen/height
====Set the system colors====
 65535 System/r
 64481 System/g
 63810 System/b
====Draw a sprite to the screen====
 %;picn% Screen/addr
 00 Screen/y
 00 Screen/x 01 Screen/sprite
 %BRK%
 %@picn% %3c7e% %ffff% %ffff% %7e3c%
Category:Languages
Swissen Machine

The Swissen Machine is an Esoteric computer devised by Jussef Swissen. (Esoteric computer in this page is defined as a computer utilizing features not normally used in popular computers.) The Swissen Machine can never exist, as the Swissen Machine contradicts with its own definition. See the talk page.
== Specifics ==
The computer the user is using to read this paper most likely runs on binary digits. The computer operates on states of 1's and 0's, on and off, true and false, yes and no. A Swissen Machine runs on only one state. Simple computer knowledge should tell anyone that this would be impossible to implement, due to the fact that a computer always has at least 2 states to perform basic logical functions(e.g. the End Of File detection states). The Swissen Machine, however, would be a computer that:
# Has no logic whatsoever, yet is still able to function.
# Instead uses the one state it has to perform computations based on environmental factors.
These are the two criteria for a true Swissen Machine. The second criteria is trivial, as all computers have stable states, and all computers have environmental factors(as shown in the talk page.) However, all attempts at implementing a language or computers would be able to fill one of these criteria, as shown in the talk page; therefore, Swissen Machines can not be implemented. The most that can be done is implementing exactly one of these criteria into a language. No equivalent computer exists that would be equivalent to its power, including the Swissen Machine.
== Language Implementation ==
Someone else has modified the small esoteric programming language called "Hugo" to help prove that the Swissen Machine is impossible to exist. It implements a Swissen Machine using the environmental factor of time and End Of Files. A valid Hugo program would consist of only one number, 1. The interpreter for this language would take exactly 1 second to process each 1 that is entered in the Hugo program. Depending on the amount of seconds taken to process the entire program, it prints an ASCII character whose decimal value is equivalent to the number of seconds taken to run the program. For example, this Hugo program prints "F".
1111111111111111111111111111111111111111111111111111111111111111111111
Hugo (inevitably and inexorably) satisfies part 2 of the the criteria need for a Swissen Machine. Languages, that are able to simulate exactly one of the Swissen Machine criteria, like Hugo, are described as, "Swissen Implemented".
Category: Concepts
Category: 2019
SwitchCase

==Memory==
SwitchCase uses variables containing unbounded signed integers.
At the start of program, the only variable is _, which is zero.
==Control flow==
The only control flow is switch-case, it is like this:
 $<variable name>
 <integer1>?<commands1>
 <integer2>?<commands2>
 <integer3>?<commands3>
 ...
 !<command>
It executes commands1 if value of variable name equals to integer1, executes commands2 if value of variable name equals to integer2, executes value of commands3 if variable name equals to integer3, etc, executes the commands after ! if none of the conditions are satisfied, the ! part is not required, in this case, nothing will be executed if none of the conditions are satisfied, but there must be at least one ? part. Duplicate integers before the question mark is forbidden.
You must use control flow to execute commands.
==Commands==
 +<nonnegative integer> Adds current variable in the switch case by <nonnegative integer>
 -<nonnegative integer> Subtracts current variable in the switch case by <nonnegative integer>
 , Input current variable in the switch case as ASCII
 # Input current variable in the switch case as integer
 . Output current variable in the switch case as ASCII
 @ Output current variable in the switch case as integer
 '<positive integer> Jump to the <positive integer>-th switch case
 =<variable> defines a variable, initially zero
==Examples==
===Hello World===
$_
0?+72.
$_
72?+29.
$_
101?+7.
$_
108?+0.
$_
108?+3.
$_
111?-67.
$_
44?-12.
$_
32?+55.
$_
87?+24.
$_
111?+3.
$_
114?-6.
$_
108?-8.
$_
100?-67.
==Truth Machine==
$_
0?#
$_
0?@
1?@
$_
1?'2
===Computational class===
Turing complete, because you can compile the two register minsky machine to it:
 Initialize:
 $_
 0?=A=B
 
 Increment A:
 $A
 0?+1
 !+1
 
 Increment B:
 $B
 0?+1
 !+1
 
 If A=0, jump to the i-th minsky machine command, otherwise decrement A:
 $A
 0?'i
 !-1
 
 If B=0, jump to the i-th minsky machine command, otherwise decrement B:
 $B
 0?'i
 !-1
Category:Languages
Category:2024
Category:Unimplemented
Category:Turing complete
Switch gr

switch gr is an esolang based on Tiny Gr, Whitespace and Piet created by User:Ractangle
==Swiches==
switch gr has 2 swiches:
*on/off
*mode
File:Off default.png|on/off:0mode:0
File:On default.png|on/off:1mode:0
File:Off alt.png|on/off:0mode:1
File:On alt.png|on/off:1mode:1
==Syntax==
===Parts===
A part is self explanatory. it's a part of the program
a line of a switch gr program is 2 (or 3 if you count the IMP part separate) parts:
*The IMP
*The command
*The arguments
===The IMP===
Just like in Whitespace, there is also an IMP, and you also have to retype the IMP once you end the current line's code
 For simplicity sake, the following code will be shown using the bit method
Code	Meaning
 	Stack manipulation
 	Flow-control
 	I/O
 	Arithmetics
===The commands===
*Stack manipulation
** - push a value to stack
** - pop a value and push it to the other stack
** - push the bos to the top and repeat that int(tos)-1 times
** - pop the tos from the other stack and add it to the main stack
*Flow-control
** - create a label
** - jump to a label unconditonaly
** - jump to a label if the tos is zero
** - jump to a label if the tos is equel to the next argument
*I/O
** - charecter output
** - numeric output
** - charecter input
** - numeric input
*Arithmetic
==Examples==
 00 00 11 11 11 11 11 11 11 01 11 11
 00 00 11 01 01 11
 00 00 11 01 01 11 11 11 11 11 11 11 11
 00 00 11 01 01 11 11 11 11 11 11 11 11
 00 00 11 01 11 01 11
 00 00 11 11 11 01 11 11
 00 00 11 11 11 11 11 11 11 11 01 11 11 11 11 11 11 11
 00 00 11 01 11 01 11
 00 00 11 01 11 01 11 11 11 11
 00 00 11 01 01 11 11 11 11 11 11 11 11
 00 00 11 01 01 01
 00 00 11 01 11 11 11
 00 00 10 10
 00 00 01
 00 10 00 00 01
 10 00 00 00
 00 10 10 00 11
 00 10 00 10 01
 00 10 00 00 11
Switchy

Switchy is an esoteric programming language created by User:Poolala, which changes an instruction's operation every program cycle.
The program stack is also reversed every cycle.
There is a binary variable called flip, which starts out at 0, and flips its value every cycle.
==Instructions==
Instruction	Description
(foo) 	Creates a label called foo (doesn't trigger a cycle)
[foo] 	Jumps to the label foo if the top stack element is nonzero if flip is 0, else jump if zero (doesn't trigger a cycle)
# 	Adds the top two stack elements, pops them, and pushes the sum if flip is 0, else subtract if flip is 1
* 	Pushes a 1 onto the stack if flip is 0, else pop a value from the stack
' 	Inputs a character and pushes it onto the stack if flip is 0, else output the top stack value
==Finite State Automaton==
Switchy is not Turing complete and acts as a Finite-state automaton.
State	Flip	State After *	State After ' 	Description
Empty	0 	A 	B 	Stack is empty(This is also the starting point)
A 	1 	Empty 	Empty(Output 1) 	Stack contains a single 1
B 	1 	Empty 	Empty(Output the input from ')	Stack contains a single character
Note: because none of the states result in a stack of size two or more, a # can not be used.
==Implementation==
An implementation in Ruby by User:OriginalOldMan can be found on Talk:Switchy.
Category:LanguagesCategory:Stack-basedCategory:Finite state automataCategory:ImplementedCategory:2013
Sword

==Introduction==
---|===> is an esolang created by User:AnotherUser05, which uses swords. The number of - corresponds to a command, and the number of = corresponds to an input.
==Commands==
Commands with * requires a sword with zero =.
Number of Hyphens	Command 	Number of Equals	Input
1 	* Start a new value. 	1-10 	Numbers 0-9.
2 	Add input to value. 	11 	Most recent value.
3 	Output a value (ASCII character). 	12 	User's input.
4 	Begin a fixed loop. 	13-15 	=, <, and >.
5 	* Begin an infinite loop. 	16 	Random number between 0 and 255.
6 	* Start of an operation declaration. 	 	
7 	* End of an operation declaration, start of an if block.	 	
8 	* End of a code block. 	 	
Any other characters are ignored, you can use these as comments.
==Examples==
===Truth Machine===
 -|>
 ------|>
 --|============>
 --|=============>
 --|==>
 -------|>
 -|>
 --|=====>
 --|==========>
 -----|>
 ---|===========>
 --------|>
 --------|>
 -|>
 --|=====>
 --|=========>
 ---|===========>
===Hello World===
 -|> H
 --|========>
 --|===>
 ---|===========>
 -|> e
 --|==>
 --|=>
 --|==>
 ---|===========>
 ----|===> repeat 2 times
 -|> l
 --|==>
 --|=>
 --|=========>
 ---|===========>
 --------|> end
 -|> o
 --|==>
 --|==>
 --|==>
 ---|===========>
 -|> ,
 --|=====>
 --|=====>
 ---|===========>
 -|> space
 --|====>
 --|===>
 ---|===========>
 -|> W
 --|=========>
 --|========>
 ---|===========>
 -|> o
 --|==>
 --|==>
 --|==>
 ---|===========>
 -|> r
 --|==>
 --|==>
 --|=====>
 ---|===========>
 -|> l
 --|==>
 --|=>
 --|=========>
 ---|===========>
 -|> d
 --|==>
 --|=>
 --|=>
 ---|===========>
 -|> !
 --|====>
 --|====>
 ---|===========>
===Cat Program===
 ---|============>
===Not Finite Loop===
 -----|>
 --------|>
===Fixed Repeating Output===
 -|>
 --|=====>
 --|==========>
 ----|============>
 ---|===========>
 --------|>
 -|>
 --|=====>
 --|=========>
 ---|===========>
 
Category:Languages
Syllad

Syllad is a language that is programmable in a usual way, but has a 'quirks mode' (up to commit ca5b34e of the repo) that lets you program in it in a way similar to JSFuck.
You trigger this by putting an = at the start of your program.
Ex: +[] returns -1 in quirks mode
== External Resources ==
* Syllad interpreter contains some documentation at the top of syd.syd and in README.md. Anything not mentioned is just whatever parser.dart does.
Category: Languages
Category: Turing complete
Category: Implemented
Symbol

A symbol is a member of an alphabet. Sometimes a bunch of symbols get together in a specific order -- this is called a string. They have also known to appear on the tapes of Turing machines and similar devices.
Symbols are generally taken to be atomic, unless explicitly described as "compound". They are also generally considered to have a visual representation (or even to be that visual representation in the sense that they are specifically that, and not the thing that is being symbolized).
For example, the symbols of a binary alphabet in common use are 0 and 1.
Category: Concepts
Symbol+Lang

Symbol+Lang is an esolang made by Mihai Popa. The goal of this is to have a language that looks slimiar to Fish and Befunge. Whitespace, tabs and line-feeds are not required but these make the code better to read.
== Commands ==
 Command list
Command 	Meaning 	Example
"text"> 	Prints a text 	"Hello!">
$"notimes" 	Start of for loop 	$5
*$ 	End of for loop 	*$
@"varname"#"varvalue"	Defines a variable and sets to a value 	@Hello#5
?"varname" 	Prints a variable 	?Hello
/"varname"\ 	Gives user input for a variable 	/Hello\
['] 	Clears the screen 	[']
%"Text" 	Marks a single line comment 	%"Hello!"
:"variable"="value" 	Start of while loop if a variable equal to a value	:c=3
*. 	Break a loop 	*.
"variable"="value" 	If a variable is equal to a value 	a=5
"variable"~="value" 	If a variable is not equal to a value 	b~=7
\= 	Else 	\=
== Examples ==
=== Hello, world! ===
"Hello, world!">
=== Cat ===
/cat\
 ?cat
=== Truth Machine ===
/truth\
 truth=0
 "0">
 \=
 :truth=1
 "1">
Category:2024
Category:Languages
Category:Unimplemented
Category:Stack-based
Category:Two-dimensional languages
SymbolLang

SymbolLang uses symbols to represent functions
== Stuff ==
=== Func ===
 ?a-a #returns input a
 ?a,b-a!b #runs a on b
 (?a-a)!hi #hi
 id=(?a-a) #named function
 id!hi #hi
== that’s it ==
It should be Turing complete
Category:Languages
Symbols

():;#?! is a small esoteric language created by User:Lucasieks in November of 2013 with only 9 instructions.
==Instruction Set==
Instruction	Action
( 	Start an infinite non-nestable loop
) 	End the infinite non-nestable loop
: 	Print the character to the right of the IP
; 	Read a character from STDIN, then overwrite the character 2 characters to the right of the IP
+ 	Increment the character to the right of the IP
- 	Decrement the character to the right of the IP
# 	Read a character from STDIN, then process it as an instruction
? 	End the program if the character to the left of the IP is a valid instruction
! 	End the program
==Examples==
===Hello World===
 :H:e:l:l:o:,: :w:o:r:l:d:!
===Cat===
 (;: )
==Interpreters==
===Javascript===
The interpreter takes in a program as input then outputs the program output.
 function Symbols(P){
 P = P.split('');
 let o = '';
 for(let i = 0; i < P.length; i++){
 switch(P[i]){
 case ')': do{ i--; }while(P[i] != '('); break;
 case ':': o += P[i+1]; break;
 case ';': P[i] = prompt('Input Char')[0]; break;
 case '+': P[i+1] = String.fromCharCode(P[i+1].charCodeAt()+1); break;
 case '-': P[i+1] = String.fromCharCode(P[i+1].charCodeAt()-1); break;
 case '#':
 do{
 let h = prompt('Input Char');
 switch(h){
 case ')': do{i--;}while(P[i] != '('); break;
 case ':': o += P[i+1]; break;
 case ';': P[i] = prompt('Input Char')[0]; break;
 case '+': P[i+1] = String.fromCharCode(P[i+1].charCodeAt()+1); break;
 case '-': P[i+1] = String.fromCharCode(P[i+1].charCodeAt()-1); break;
 case '?': if('():;+-#?!'.includes(P[i-1])){i = P.length;} break;
 case '!': i = P.length;
 }
 }while(h == '#');
 break;
 case '?': if('():;+-#?!'.includes(P[i-1])){i = P.length;} break;
 case '!': i = P.length;
 }
 }
 return o;
 }
Category:Languages
Category:Self-modifying
Category:2013
Symmetrical program

The concept of a symmetrical program is an extension of the concept of a palindromic program into multiple dimensions.
==Definition==
A symmetrical program in an n-dimensional language has at least one n-1-dimensional surface of symmetry. For example, a symmetrical program in a 2-dimensional language has at least one line of symmetry, and a symmetrical program in a 3-dimensional language has at least one plane of symmetry. A palindromic program is therefore a symmetrical program in a 1-dimensional language.
Symbols in the program may be regarded as self-symmetrical, or alternatively may be associated with their visual representations and hence form symmetrical pairs (for example, an opening bracket may be regarded as the symmetrical partner of a closing bracket, dependent on the direction of symmetry). This is essentially required for palindromic Brainfuck programs.
==Non-triviality==
Formally, a symmetrical program is regarded as non-trivial if every instruction within it is executed for some input data (but not necessarily the same input data for each instruction). Informally, an additional requirement may be that the program perform some "non-trivial" (that is, complex) task.
==Examples==
Safalra has produced many symmetrical programs in his language Sansism, of which two examples are given below.
The following Sansism program, exhibiting symmetry around a vertical line, outputs the ASCII or Unicode table and then halts, dependent on the implementation:
 G.G
 >G+G>
This may be regarded as trivial in the informal sense. The following more complex Sansism program, exhibiting symmetry around a horizontal line, outputs the string HELLO. The left-hand side demonstrates a generic symmetrical multiplication routine, and the right-hand side demonstrates a generic symmetrical output routine. Note that the output is produced by a six-character loop, but an additional thirty-nine characters are used to guarantee symmetry.
 GG
 G + G G--G +
 GG G-G G G +G
 >+++++++++++++++++++!!!!!#>#++++!++++!++++!++++!++++!-# G#!----!-------!!!+++##!!!!!##+ +G>!>.!G --
 GG G-G G G +G
 G + G G--G +
 GG
==External resources==
*Palindromic Programs In Sansism 
Category: Program forms
Symmetry

Symmetry is an esoteric programming language designed under the observation that most traditional languages use Hashmaps to store data, but that this practice is more for programmer's convenience than for necessity (see: any other esolang ever, where the data model is anything but a hashmap).
== Idea ==
Most traditional languages use hashmaps to store data; that is, a key→value pair. Symmetry, on the other hand, uses a Wikipedia:Bidirectional map, or hashbag, to store its data; that is, key↔key pairs. This means, essentially, that bm[k]=v↔bm[v]=k (the arrow there being "iff" in this case, not the earlier-used key↔key syntax). This leads to a few interesting properties; for example, that the assignment expression x=y is logically equivalent to y=x.
== Syntax ==
The syntax of Symmetry is fairly trivial; it looks quite like a normal language (as one of the common reasons esolangs look abnormal is that they're dealing with a strange data model, which we are not here). Note that all syntax is tentative; none of it will necessarily stay for long, until the author feels it is complete.
=== Tokenization ===
Regex 	Tag 	Feature name
^[\s]+ 	NULL 	Whitespace is ignored.
^"[^"\\]*(?:\\.[^"\\]*)*"	STR 	Strings are enclosed in double quotes, but may have double quotes inside them backslash-escaped
^[0-9]+(\.[0-9]+)? 	NUM 	Numbers are both floating-point and integers; they are of the most traditional of syntaxes
^= 	ASSGN	Assignment: One of the must integral parts of languages, especially symmetry
^(\+|\*|-|/|%|&|\ 	OP 	Operators are useful. Arithmetic (including modulus), boolean, relational.
^[{}()[\]] 	BRACK	Curly brackets close of blocks, parentheses group expressions, and square brackets are reserved in case I ever feel like using them
^[a-zA-Z_][a-zA-Z0-9_]* 	NAME 	Identifiers. Really just used for functions; can't be used in assignment.
^, 	NAME 	
^IF 	IF 	Conditionals
^ELSE 	ELSE 	Failure conditionals
^WHILE 	WHILE	Loop-de-loop
=== Grammar ===
 value ::= STR | NUM ;
 pexp ::= "(" exp ")" ;
 fexp ::= NAME "(" [{exp ","} exp] ")"
 exp ::= fexp | pexp | value OP value ;
 
 ifthen ::= "IF" exp "{" {stmt} "}" {"ELSE" ifthen} ["ELSE" "{" {stmt} "}"] ;
 while ::= "WHILE" Exp "{" {stmt} "}" ;
 stmt = while | ifthen | exp
Syms

Syms is a stack-based language made by User:CatIsFluffy without many built in stack manipulation operators, but tools to build them.
==Commands==
These are for the latest versions of Syms (1.4+). For older versions, please refer to this old version of the page.
Code 	What it does
{...} 	Push "..." to the stack as a string. Nestable.
$c 	Push "c" to the stack as a string.
number 	Push number to the stack as a number.
\ 	Escape the next character in a string.
& in string 	Insert top of stack into string.
" 	True
' 	False
> 	Print
< 	Input
+ 	Add/join strings (b+a pop a first)
- 	Subtract (b-a pop a first)
* 	Multiply/string repeat
/ 	Divide (b/a pop a first)
; 	Cast to number
= 	Equal
! 	Logical NOT
& outside of string	Logical AND
| 	Logical OR
@ 	Index into string
# 	Length of string
: 	Cast to string
~ 	Swap top two stack elements
] 	Pop
) 	Execute string as code
? 	If top element then ) else ]
( 	Escape a string (surround with {} and escape &\)
[ 	Duplicate
_ 	Stack empty?
==Examples==
Self interpreter (no autoprint)
 {Program:}<)
==Interpreter==
Available at Github or run programs at Try it online!
Category:Languages Category:Stack-based Category:Implemented Category:Unknown computational class Category:Usability unknown
SynDev

SynDev is a language created by User:iconmaster whose purpose is to check the syntax of programs in other languages. 
== Structure == 
SynDev programs are a list of definitions. Each definition is made of strings, alternations, charsets, and other definition names. Each of these will match a certain string in a text file given to it, going in order.
A definition is written like this:
 def = item1 item2 item3 ... itemn
Where each item is a valid SynDev item.
Strings are a series of characters in double quotes. They literally match whatever is inside them.
 "STRING"
Alternations are a list of items in square brackets. They will match the first thing in the list that can match.
 [ thing1 thing2 thing3 ]
Charsets are a series of characters in parenthesis. They will match the first character that matches in the text. You can use % to detonate special character ranges just like in regular expressions.
 (abc%d)
You can use names of other definitions in the program as well by rererring to thier definition name. In addition, they can have a one-character prefix. 
* * matches zero or more repetions of the definition.
* + matches one or more repetions of the definition.
* ? matches zero or one repetions of the definition.
 *SPC
Note that there are some built-in definitions in SynDev. They are the following:
* SPC is equal to (%s)
* QUOT is equal to (")
* ANY is equal to (%a%A)
* NEWL is equal to (\n)
* LTRS is equal to (%w)
* NUMS is equal to (%d)
* LTNM is equal to (%a)
Comments begin with a # and continue to the end of a line.
 # this is a comment.
== Implementation ==
The last definition of the program is called the root definition. The root definition is what SynDev looks at first when going into a program. It attempts to match the items in the root definition. If there are definition names, it 'goes into' the definition and attempts to match that. The program returns false if one of the items in the root definition does not match, else it returns True. 
== Examples ==
RPL:
 endchar = (%a%d←↑→↓)
 varname = +LTRS *endchar
 string = QUOT *ANY QUOT
 number = +(%d)
 prog = "«" *prgpiece "»"
 list = "{" *item "}"
 notspc = (%S)
 funcword = +notspc
 grob = "GROB" number number ?(%x)
 alg = "'" *ANY "'"
 item = [number string alg prog list grob varname funcword]
 ifthen = "IF" *item "THEN" *item "END"
 ifelse = "IF" *item "THEN" *item "ELSE" *item "END"
 if = [ifthen ifelse]
 startnext = "START" *item "NEXT"
 startstep = "START" *item "STEP"
 start = [startnext startstep]
 fornext = "FOR" varname *item "NEXT"
 forstep = "FOR" varname *item "STEP"
 for = [fornext forstep]
 casepart = "CASE" *item "THEN" *item "END"
 case = +casepart "END"
 while = "WHILE" *item "REPEAT" *item "END"
 do = "DO" *item "UNTIL" *item "END"
 branch = [if for case start do while]
 prgpiece = [branch item]
 program = *prgpiece
Category:2011Category:Meta-languagesCategory:UnimplementedCategory:Languages