nyuuzyou/wikis huggingface dataset:
Streetcode

Streetcode is a two-dimensional esolang by User:PythonshellDebugwindow. Its syntax resembles a network of streets.
==The car==
The car, which works like an instruction pointer, navigates through the streets.
==Memory==
Streetcode uses unbounded signed integer cells and a cell pointer, referred to as CP which starts at 0 like all of the cells. The CP is unsigned and right-unbounded.
==Streets==
All streets are two-way. They are two characters wide. The car always drives on the right-hand side. The characters the car pass over while driving are instructions.
Character	Effect
^ 	Increment CPth cell
~ 	Decrement CPth cell
= 	Increment CP
_ 	Decrement CP
; 	Halt the program
I 	Set Nth register to user input character
O 	Output Nth register as character
U 	Turn the car around
space 	Nop
Therefore this:
 +----+
 | |
 |CIO;|
 +----+
would drive on the whole right-hand side of the street, stopping only when the semicolon (halt command) is reached, and copying a user input character to output along the way. The C character represents where the car starts; exactly one of these must appear in each program.
This is an infinite cat:
 +----+
 |UOI |
 |CIOU|
 +----+
The Us can be replaced with spaces in this case.
===Dead ends===
If the car reaches a dead end, it will turn around.
===Ambiguous turns===
If a street has more than one possible turn (e.g., it's at an intersection), the leftmost road will be driven down if the CPth cell is equal to zero otherwise the second-leftmost one will be. Leftmostness is relative to the direction the car is driving, treated here as down.
==Examples==
===Infinite loop===
 +-------+
 | |
 |C |
 ++ ++ |
 | ++ |
 | |
 | |
 +------+
===Infinite cat for single characters===
 +--------+
 | |
 |C^ |
 +-+IO++ |
 |OI++ |
 | |
 | |
 +------+
Why wouldn't this be a cat?
==Turing-completeness proof==
Streetcode is Turing-complete, as ambiguous turns provide control flow and it has unbounded memory through < and >.
Category:Languages Category:2020 Category:Turing complete Category:Thematic Category:Two-dimensional languages Category:Unimplemented Category:Concurrent programming
String

A string is a data type used both in traditional programming and many esolangs encoding a sequence of symbols chosen from some alphabet (generally ASCII or Unicode). The string with no symbols is called the null string and is sometimes denoted by ε.
Almost all programming languages - esolangs and traditional languages alike - are usually presented encoded in the form of a string; while traditional languages are rarely encoded as anything else (the exceptions usually being graphical languages designed for ease of learning), esolangs based on other models, such as images (e.g. Piet) or music (e.g. Musical notes), are designed with some frequency.
Programming languages, esoteric or not, also usually accept and show strings as their default (or only!) forms of input and output. If a language outputs the string its own source code, it is referred to as a quine.
Several languages exist which are based on rewriting strings, the most well-known being Thue.
==See also==
* :Category:String-rewriting paradigm
* :Category:String-based, languages which use strings as their main data type
Category:Concepts
Category:Data Types and Structures
String-rewriting paradigm

==Syntax==
It only has 2 extremely simple commands. They are:
 >
This moves the first byte of the program to the end of the program.
 Any other byte
That is printed into console and is deleted.
Code is executed in cyclic sequence.
==Examples==
Hello, World!:
 Hello, World!
Infinite loop:
 >>>
==Interpreter==
Written in Python.
def string_rewriting_paradigm(program):
 program = list(program)
 i = 0
 while program:
 if program[i] == ">":
 program.append(program.pop(0))
 else:
 print(end=program[i])
 del program[i]
 if i == len(program):
 i = 0
Category:Languages
Category:String-rewriting paradigm
Category:2018
Category:Output only
Category:Implemented
Category:Unusable for programming
Category:Finite state automata
StringSafunge

StringSafunge is an esolang created by User:None1, it is Befunge-93, but string-safe in most languages.
==Commands==
 Commands that are different in StringSafunge and Befunge-93
In StringSafunge	In Befunge-93
a 	\
b 	"
c 	`
Other commands are the same.
Category:Languages
Category:Push-down automata
String rewriting paradigm

String rewriting paradigm is a programming language invented by User:A.
==Syntax==
d: duplicate the next character.
Example: d* results in **.
!: pushes the last character in the current line
@: pops the top of the stack to the end of the line.
:: Outputs every character before the colon.
==Examples==
===Infinite loop===
 dd
===Looping counter===
 !@:
Category:Unusable for programming
Category:Languages
Category:2019
Category:Output only
Strucked

Strucked is an esoteric programming language thought up by User:1hals.
It is a Declarative Programming Language for describing simple binary file formats.
The name is a pun on the word "struct".
The main difference between this a C-style structs is that the size of further fields can depend on the value of previous fields.
The purpose of this is to be a simple schema for defining scary file formats where the sizes of the fields can be different depending on the file's data (via the size expressions).
== File contents ==
A file is a series of declarations that determine the file format via field types.
Declarations consist of a name/identifier, size, and type.
Identifiers must appear in a previous declaration before they can be used in subsequent ones.
== Size expressions ==
When specifying the size of a type, an RPN expression involving previously defined identifiers is allowed.
Also, the RPN expression may use the following stack operators:
* * (2 operands) multiply 
* + (2 operands) add 
* / (2 operands) divide 
* - (2 operands) subtract
* & (2 operands) bit-and
* | (2 operands) bit-or
* << (2 operands) left shift 
* >> (2 operands) right shift 
* = (1 operand) duplicate
* $ (no operands) swap 
* _ (no operands) drop 
* An empty size, written as (), represents a freely variable-sized array (like [] in C), which may or may not be valid, depending on the context
== Data types ==
The basic types are:
* bbyte: big-endian bytes (when more than 1)
* lbyte: little-endian bytes (when more than 1)
Compound types are constructed by surrounding a series of declarations within [square brackets].
Note: only fields can be named, not types, so if you need to use a type in multiple places, you just have to copy-and-paste the field definitions.
== Syntax ==
EBNF grammar (ignoring whitespace):
whole file = decl, { decl }
decl = name, "(", [ expression ], ")", type
type = "bbyte" | "lbyte" | compound
compound = "[", decl, { decl }, "]"
expression = ( name | number ), { name | number | operator }
operator = "*" | "+" | "/" | "-" | "&" | "|" | "<<" | ">>" | "=" | "$" | "_"
name = ? Word not starting with a 0-9 ?
number = 0-9, { 0-9 }
 
== Examples ==
In the examples below, the # symbol is used for comments.
=== String file ===
 width (1) bbyte # identifier "width" is 1 byte at the beginning of the file (endianness doesn't matter for size of 1)
 count (width) lbyte # identifier "count" is "width" bytes refering back to the identifier, little endian
 string_pointers (count) # identifier "string_pointers" is "count" instances of the following group made by the brackets
 [ offset (width) lbyte # indentation is ignored/optional
 length (width) lbyte ]
 strings () # identifier "strings" is an unlimited array
=== Using math ===
 half_count (4) lbyte
 data (half_count 2 * 1 -) [ # here we calculate (half_count * 2) - 1
 x (4) lbyte
 y (4) lbyte
 ]
== Challenge ==
If you want a programming challenge/project, implement an API for reading/writing files using a given Strucked schema.
Category:No IO
Category:2021
Category:Languages
Category:Declarative paradigm
Structure

The Structure lang is made of four commands (though endif is not really a command):
. and < and >, and endif.
==Commands==
  (space) is a command delimiter, meaning it separates commands.
. the current 'pointer'.
.. means add to the current 'pointer'.
... means subtract [from the current/the next] 'pointer'.
..... means switch to ascii format.
.... means divide [from the current/the next] 'pointer'.
...... multiply [from the current/the next] 'pointer'.
> means if there is not direct information move 'pointer' right.
< means if there is not direct information move 'pointer' left.
<< means current pointer information stops here.
>> means use the information before it to control what's after it.
endif means run the code, and end the program if the code information ends.
.> or <. means string apart (depending on the directiong it points to) as literals.
>. or .< means string together (depending on the direction it points to) as literals.
<> means delimiter to link different values for later use.
{} anything inside of the "{" and "}" is a comment, and ignored by the program.
==Syntax==
It is made of a structure closely similar to Brainf.
The first program made in it is actually "10".
==Examples==
===10===
 . .. > .. .. < .. > .. .. <
 endif
===Hello World===
 . <> . ... . <> . .. . .. . .. . <> << ..... {"h"} <>
 endif
More of the literal letters of 'hello world' will be posted later.
An Implementation is allowed, write your username under this between "[" and "]" to tell who is implementing this.
[]
Category:Languages
Category:Unimplemented
Category:2020
Category:Low-level
Structure-free Query Language

The Structure-free Query Language is an alternative to the popular Structured Query Language (SQL).
It was created in 2015 by User:OriginalOldMan.
==Data==
As suggested by its name, data in the Structure-free Query Language has absolutely no structure. The Structure-free Query Language's
databases are called pools. This is because when data is inserted into a pool, it floats around aimlessly with little
hope of being retrieved.
Each bit of data is stored in the pool as a base-36 integer, with the digits represented from 1-z.
==Commands==
Like most programming languages, the Structure-free Query Language allows programmers to use various commands to manipulate data. For example the command to insert data into the pool is INSERT.
Just like data, commands in the Structure-free Query Language have no structure.
The following code inserts hello into the pool:
INSERT hello INTO POOL
However, this code does the same:
INTO POOL INSERT hello
As does this:
hello POOL INTO INSERT
As does this:
POOL INTO hello INSERT
Other "useful" commands:
Command 	Meaning
DELETE FROM POOL 	Removes all data from the pool.
SELECT DATA FROM POOL	Selects a (random) piece of data from the pool.
SELECT * FROM POOL 	Selects all the data in the pool.
SET EQUAL TO DATA 	Sets the selected data to a random piece of data from the pool.
INTERMINGLE WITH DATA	Intermingles the digits of the selected data and a random piece of data from the pool. For example, if the selected data was aaaa and the random piece was bbbb, the end result would be abababab.
DO MATH WITH DATA 	Performs a random math operation (+,-,*,/,%) between the selected data and a random piece of data, then sets the selected data equal to the result.
==Example Programs==
The following program has a 20% chance of adding 1+1:
POOL 1 INTO INSERT
INSERT POOL INTO 1
DO DATA MATH WITH
This is the closest one can get to a "Hello, world!" program in the Structure-free Query Language:
INSERT POOL INTO hello
world POOL INTO INSERT
Category:Languages
Category:2015
Structured Minsky

Structured Minsky is a restricted variant of Portable Minsky Machine Notation.
== Structure ==
A Structured Minsky machine SM(n) has n many counters, as well as a conditional bit and a temp bit.
The following commands are available in Structured Minsky:
Command	Effect
+n 	increment counter n, where n is any nonnegative integer
-n 	decrement counter n, set conditional if n changed value, else clear
[ 	if conditional bit is cleared, skip forwards to matching ], else continue
] 	skip backwards to matching [
! 	unconditionally flip conditional bit
x 	swap conditional bit and temp bit
c 	copy conditional bit to temp bit
The construction -n [{code} -n] is therefore identical to the while construct in PMMN.
Using these the if structure can be created:
 -n
 [ +n -n ! c
 {code}
 +n -n ! c
 ]
Such that n is the counter to test. Oneshot execution is accomplished by setting the conditional bit to 0. To do this the construct +n -n, which always results in a change of value on decrement without an ultimate change to n, is used to set the bit. ! inverts the always set to be an always clear. c copies it to ensure that the temp bit is also 0. The copy operation, as well as the duplication of the construct at the beginning of the loop, are not strictly necessary.
If-else can be constructed in this manner (for counter n):
 -n
 c
 !
 [
 +n -n ! c
 {else}
 +n -n ! c
 ]
 x
 [ +n -n ! c
 {if}
 +n -n ! c
 ]
== Turing completeness ==
Since any PMMN program can be converted into Structured Minsky, it is therefore Turing complete. Further, since a Minsky machine with two counters is Turing complete, SM(n) for n ≥ 2 is also Turing complete.
== Variants ==
The temp bit can be swapped for a counter. The ! should be possible to remove in a similar way.
Category:Turing complete
Category:2023
Category:Unimplemented
Category:Languages
Structures

There are mainly 3 types of structure for a language. flat, nested, and flat-nested.
==Flat==
Programs in flat languages can be split into a sequence of commands, the commands may have arguments, but these arguments are not automatically passed from the previous command.
Example of flat languages:
* brainfuck
* subleq
Most esolangs are flat.
==Nested==
Programs in nested languages are like expressions, every command has no argument or has its arguments passed from its sub-command, and usually returns a value. These languages are usually parsed recursively.
Example of nested languages:
* Setlang
* 13 bytes :D
==Flat-Nested==
Programs in flat-nested languages can be split into a sequence of nested commands.
Example of flat-nested languages:
* C
* Python
Category:Concepts
Strvar

Strvar is an esolang by User:PythonshellDebugwindow based on string rewriting.
==Syntax==
Every non-blank line in a valid Strvar program is either a variable definition or a lone string literal. Variable definitions look like this:
 myVar = "myString";
Lone string literals look like this:
 "myString";
A lone string literal on a line will be output followed by a newline. Valid escape codes in strings are \r \n \" \t \xhh. Variables can be reassigned a new (or the same) value. Variable names must match the regex [^\s"#;=]+. Spaces outside of strings are ignored, including in variable names, so at assignment, "my var" and "myvar" are the same variable, both changed to "myvar". Comments are denoted by a #, are ignored, and last until end-of-line.
==String rewriting==
Each time a string literal is evaluated, it is checked to see if it contains any variable names. If it does, then the following actions take place:
# The first occurrence of a variable name in the string is replaced with the variable's value.
# If there is still a variable name in the string, then repeat the process.
This will result in an infinite loop if a variable used in a string is set to its own name, as it will always contain the name (and value) of the variable.
==Examples==
===Hello, World!===
 "Hello, World!";
Showing off more features:
 h = "Hello,";
 w = "World!";
 "h w";
The string ends up with infinitely many "orld!"s on the end, and never gets printed out because the program goes into an infinite loop:
 h = "Hello,";
 w = "world!";
 "h w";
===Truth-machine===
Change "0" to "1" for input 1. Loops forever for 1 = "1";, prints 0 for 1 = "0";.
 1 = "0";
 "1";
===Interpreter test cases===
This code:
 a = "b";
 b = "c";
 "a";
should print "b", and this code:
 b = "x";
 a = "b";
 b = "y";
 "a";
should print "x".
===Counter===
This program prints the string “1 2 3”:
 one = "1";
 two = "one 2";
 three = "two 3";
 "three";
==Resources==
* An unfinished interpreter written in NodeJS
* Common Lisp implementation of the Strvar programming language.
Category:Languages Category:2020 Category:Implemented Category:String-rewriting paradigm Category: Output only
StuLa

StuLa (Stupid Language) is a programming language, made by User:CMinusMinus in 2019. It has variables, import options, input and output, 3 main variable types and functions.
==Variables==
Operator instructions:
{| class="wikitable"
|-
! Operator !! Function
|-
| X>
like
 func/<<my_func>>
Functions have to end with "<<>>"
===Calling functions===
You only can call functions, by defining them with a variable:
 x<!-My_Function
To add arguments, do
 x<!-My_Function & My_Argument_1 & =Some_var! & (...)
To get an argument in a function, do
 [POSITION_OF_ARGUMENT]
like
 [0]
while 0 is "My_Argument_1" and [1] would be the value of "Some_var".
To return a value from a function into a variable, do
 ..TEXT
like
 ..Hello, =username!.
So if you want to have a function, that gets an user input and saves it into "my_input", it would look like this:
 func/<<getinput>>
 i<?-TEXT:=_!
 ..=i!
 <<>>
 my_input<!-getinput
 out:line/=my_input!
===Importing functions===
To import a function from another file, do
 take FILENAME
like
 take my_functions.txt
Now you are able to use these functions, like normal ones.
There are also some built-in functions, that allows you, to
* Clear the terminal (StuTerm)
* Write in different colors (StuTerm)
(WIP)
You can import built-in functions, by typing
 take your_function
like
 take StuTerm
==Examples==
===Hello, World!===
 out:line/Hello, World!
or
 func/<<hw>>
 ..Hello, World!
 <<>>
 text<!-hw
 out:line/=text!
===Cat===
 i<?-Input Something:=_!
 out:line/=i!
==Run==
To run the StuLa Interpreter, do
 StuLa.py code.txt
If you changed some of this enviroment variables, you don´t need the ".py"
==Links==
*GitHub Python Interpreter
Category:Languages Category:Implemented
StubScript

StubScript is an extremely simplified esolang invented by User:A, so simple that it made this article a stub.
==Syntax==
It has only 1 instruction:
 >
Move the first byte to the end of program.
Any other command is an error. (They don't exist)
That makes it extremely useless, and it is not capable of doing anything except for halting immediately or an infinite loop.
== Examples ==
=== Infinite loop ===
 >>
Golfed:
 >
== Interpreter ==
Written in JavaScript.
 function stubScript(code)
 {
 code = code.split("")
 for(var i = 0; i < code.length; ++i)
 if(code[i] === ">")
 code.push(code[i]);
 else
 throw new Error("Invalid command " + code[i]);
 }
Category:String-rewriting paradigm
Category:Languages
Category:2018
Category:Implemented
Category:Unusable for programming
Category:Push-down automata
Category:Self-modifying
Stueue

stueue is a stack but when you pop something off the top it switches to bottom, making it a queue every even-numbered pop and a stack every odd-numbered pop. duplicates, peeks, and other similar non-popping operations do not change the position. drop does change the position, however
its "being popped" value is called bop overall.
== operations ==
 pop - return and remove bop of stueue and then toggles queue mode
 drop - remove bop of stueue and then toggles queue mode
 peek - return bop of stueue without removing it
 dup - duplicates bop
 swap - swaps bop and pre-bop
 rot - rotates bop, pre-bop, and pre-pre-bop.
 rotcc - same as rot but counter clockwise
== trick to ensue a switch ==
 dup drop
category:data Types and Structurescategory:2024
Stuley

Stuley is an alternative universe version of the CSS language made by Alice Luxemborg, made as an add-on for MarkupL.
==Syntax==
It's basically the same as a CSS program:
Also since Interactive Script has a capability to change contents of something (e.g. ). By adding a and a dot next to a target id (e.g. ). Interactive Script will just turn the replacement into a Stuley style code and add it to the target id's style
Here is the example:
Category:Languages Category:2024
Stupid

Stupid is an esoteric programming language by User:A, and is made up entirely of variables. Each line is just a case-sensitive variable name, followed by =, and then the variable's case-sensitive value.
The variable names can be anything including special names, and the values can be anything as well, and can also be special values:
IN 	inputs the variable. (Set the var as input)
OUT 	outputs a variable.
cnd.	starts a while loop named x with the given condition. The while loop's commands should have a tab or 4 spaces.
== 	equal to. Only used in while comdition.
==Example==
===Hello World===
 hw=Hello, World!
 hw=out
===Truth-machine===
 v=IN
 v=OUT
 x=v==1.
 v=OUT
Category:Languages Category:2018 Category:Unimplemented
SubI machine

SubI machine is an virtual esomachine(can be considered as esolang) created by User:Слон из ЖЕЛЕЗА.
It operates on complex numbers, which are written in base i-1.
==Execution==
Firstly the string, which is made out of 0s,1s and newlines(you can use whitespaces, but they are ignored).
The string is separated and stored in a complex-indexed array as words - numbers in base i-1 with a certain length(specified in config).
The instruction pointer starts at 0, then it goes to the direction of 1 and finds commands with arguments next to it.
==Commands==
Command(as a word of length 13)	Command(as a number)	Description
1111111111111 	-38+13i 	Ends program
0000001110111 	3i 	Prints at the position of the 1st argument the chracter of the code, that is the real value of the 2st argument, with curses atributes of the imag value.
0110111001100 	42 	Goto.
0000110011110 	5-7i 	If the value under the argument is 0, then go up by i, else skip.
0000110011110 	2+17i 	Adds 2nd argument to the value under the first argument.
0000100011111 	14+i 	Copies the value under the second argument to the cell under the first.
0001101110111 	19i 	Shifts by the value under the second argument value under the first.
0110110110110 	39-13i 	getch(), value stored under the argument.
0000000011101 	-1 	Negates the argument.
0000001100000 	4+4i 	Performs SubIwise and.
1111110011111 	-42+9i 	Performs SubIwise or.
==Turing-completeness==
SubI machine can simulate BrainFuck, so it's turing-complete.
Todo: how to translate a brainfuck program to SubI machine
==External Resources==
Implementation
Category:2023
Category:Languages
Category:Implemented
Category:Turing complete
Category:Two-dimensional languages
Subleq+

Subleq+ is a variation of Subleq which uses negative values for indirect memory access.
Subleq+ allows self-modification, but is suspected to be Turing complete even if you don’t use self-modification. However this has not yet been proven.
== See also ==
* Subleq
* Trichotomy
== External resources ==
* Subleq+
* Subleq+ implemented in Python
Category: OISC
Category: Implemented
Category: Turing complete
Category: Low-level
Category: Self-modifying
Category: Cell-based