nyuuzyou/wikis huggingface dataset:
Seribund

Seribund is a one-instruction esolanguage designed by User:Keymaker in 2014.
==Description==
A program is a list of instructions. Each instruction is executed the number of times the previous instruction modified a register's value to. Initially, for the very first instruction to be executed in the program, this number is 1. Each instruction modifies a register. Registers may hold any integer, but assigning a negative value to one causes the execution-number for the next instruction to be negative, which means the program will terminate (successfully). If the execution-number is 0, the next instruction will not be executed, and the instruction after it will be executed with the execution-number 1. Program flow moves from one instruction to the next, skipping to the first one after the last one.
==An example==
 (a1+1)
On the first cycle increases a1-register (initially 0) to 1. The execution-number for the next instruction is thus 1. This one instruction being the only one in this program, it will be executed again. Now a1 has 1, so it will become 1+1=2. The execution-number is now 2 for the next instruction. Now, (a1+1) will be executed twice. First 2+1=3, then 3+1=4. Now the execution-number is 4 for the next. 4+1=5, 5+1=6, 6+1=7, 7+1=8: a1 is now 8 and the next instruction will be executed 8 times... This goes on infinitely.
==Computational class==
The language is Turing-complete. There is a way for translating Minsky machine to it. A tool can be found here: http://yiap.nfshost.com/esoteric/seribund/mmtoser.py While proving the Turing-completeness of it, translating Minsky Machine does not as such take much advantage of Seribund's features. An eventual plan by the author is to create a more expressive language that compiles to (slightly more) efficient Seribund code.
==External resources==
* Seribund page (the specs, a MM-to-Seribund translator, an interpreter in Python)
* Another Interpreter (Go Seribund Interpreter by User:Bismarck71 with some differences)
Category: Turing complete
Category: Turing tarpits
Category: Low-level 
Category: Languages
Category: No IO
Category: Implemented 
Category: 2014
SetBang

SetBang (or S∈tBang) is a language based on a foundation of all mathematics: set theory. It is recommended that you do not use it for anything where performance, readability, or programmer sanity are requirements. However, it’s probably great for job security. It was created by Michael O. Church.
== Explanation ==
SetBang is stack-based, and features a single data type, the set.
* Initial blog post.
* The second blog post.
* The third blog post.
==Commands==
== Examples ==
=== Hello World ===
6^#~8[2>'2>\_#]_!5^#[2>'2>\_#]_~5[2>'2>\_#]_!~9 [2>'2>\_#]_~~!!3[2>'2>\_#]_~!5^#~9[2>'2>\_#]_!!~8 ][2>'2>\_#]_!~!~3[2>'2>\_#]_!~3[2>\_#2>\_#]_!9[2>\_#2>\_#]_!5^#'!9'!___
== Implementations ==
* The original implementation, written in Clojure.
Category:Languages Category:Implemented Category:Stack-based
SetGoto

SetGoto is OISC by User:ChuckEsoteric08.
Command looks like that:
 a;b;c;d;
Declare label a, set variable b to c and if it is "false" go to label d.If you want set to variable then it is needed to be inside two %'s, making possible to go to label specified by variable
==Computational class==
It is Turing-complete, because it is possible to compile 1-bit BF to it. For example:
Flip bit and if 0 then goto a, else if 1 goto b:
 flip1;bit;true;b;
 flip2;cond;false;a;
This can be used for compiling.
==External resources==
Compile SetGoto to Batch
Category:Languages Category:OISC Category:Turing complete Category:Turing tarpits
Setlang

Setlang is an esolang created by User:None1, inspired by the representation of Python data structures, it is very simple.
==Commands==
Command 	What it does
{} 	Ask a character from user input and return.
{a,b,c,...}	Concatenate the strings (chars are strings, too), together and return.
[CODE] 	Run the CODE forever.
(string) 	Output the string.
 	Output "Nope." (without quotes).
==Example Programs==
===Hello World===
 ("Hello World!")
===Cat Program===
 [({})]
===Nope. interpreter===
===Greeting===
The following program queries the user for a single character from their name and prints a greeting message embedding this piece of information. The example also demonstrates a character without quotation marks, as an alternative to a string, in the context of concatenation.
 ({"Hello,",{},!," How are you?"})
======
 (4)
==Interpreter==
* Common Lisp implementation of the Setlang programming language.
==See also==
* Hole
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:Nested
Setlang++

Setlang++ is an esolang invented by User:None1, it is a derivative of Setlang, and its original goal is to write a Truth Machine.
==Extra Syntax==
Command 	Meaning
[a,b] 	Compare the value of a and b, if they're the same, return a, otherwise return an empty string.
[a,CODE1,CODE2]	If a is not an empty string, then execute CODE1, otherwise execute CODE2, returns an empty string.
==Example Programs==
===Truth Machine===
 [[{},0],(0),[(1)]]
Category:Languages
Category:Unusable for programming
Category:Joke languages
Category:Unimplemented
Category:Nested
ShaFuck

ShaFuck is a version of Brainfuck that is intended to be nigh-on impossible to write.
A ShaFuck program may be any sequence of bytes of a length greater than zero which is a multiple of 1024. The SHA-1 sum of every 1024-byte chunk is calculated, and all of the SHA-1 sums are then concatenated. This sequence of SHA-1 sums is interpreted as Brainfuck code, with the caveat that comments are not allowed. Each 1024-byte chunk in the source therefore represents 20 Brainfuck operations.
A ShaFuck interpreter written by Gregor Richards is available at http://codu.org/eso/shafuck/.
== Cryptanalysis ==
In December 2012, Shinichiro Hamaji has found a vulnerability that the current (0.2) implementation of ShaFuck does not check if the code is a comment when the code is never executed. Taking this advantage he was able to write a straightforward translator from Brainfuck to ShaFuck.
Category:Languages
Category:Implemented
Category:Brainfuck equivalents
Category:Low-level
Category:Turing complete
Category:Brainfuck derivatives
Category:Unusable for programming
ShadyAsFuck

ShadyAsFuck is a language develped by PPCG users VTCAKAVSMoACE and flawr in the night from October 9th to October 10th 2015. It is substitution encoding of BrainFuck. But instead of a one to one encoding, two BrainFuck commands are encoded in one ASCII character in order to make it more memory efficient and more suitable for golfing, as it uses 72 characters instead of only 8.
The substitution works as follows: The whole source code is split up in pairs, each pair will be replaced by a new character according to the following table. The first character determines the row, the second character determines the column. The last column is made for programs that have an odd number of BrainFuck commands. But these characters can also be used in the middle of ShadyAsFuck code. This column also ensures that BrainFuck code also works in ShadyAsFuck without substitution.
 	+	-	<	>	[	]	,	.	[none]
+	P	O	s	h	a	d	y	_	+
-	0	M	A	S	f	u	c	k	-
<	n	G	L	x	Y	p	Q	J	<
>	g	m	o	R	5	e	U	2	>
[	j	3	b	z	{	(	I	V	[
]	W	E	B	=	)	}	Z	T	]
,	t	H	i	N	K	!	;	C	,
.	F	l	4	w	r	X	D	:	.
Note: Interestingly, because of the syntax for having nothing as the second command, one can even run Brainfuck codes through ShadyAsFuck.
This table is carefully chosen, as it contains important information even without the context of the subsitution. There are in fact choices that were made for user friendliness, mainly the characters on the diagonal as well as on the sub/super diagonals:
BF SAF crib
++ P Plus
-- M Minus
<< L Left
>> R Right
[[ { left brace
]] } right brace
.. : two dots
,, ; two commas
-+ 0 useless
+- O useless
>< o useless
<> x useless
[] ( open parenthesis (only used in very particular situations)
][ ) closed parenthesis
,. C cat (reads one char and outputs)
., D dog (opposite of cat)
An example of Hello World:
PPPPzPPzPgPgPgLLuggmRapG=2mMFPPP:P_R4kJP_MMMlMMMkR_g_
Which, in brainfuck, is:
++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
== External resources ==
* ShadyAsFuck Source Code and Compiled Code (for actual use)
* Online ShadyAsFuck to BrainFuck to ShadyAsFuck converter
Category:Brainfuck derivatives
Category:Languages
Category:Cell-based
Category:Turing_complete
Category:2015
Shameful

Shameful is an esolang created by User:None1. It is shameful enough to be put into the :Category:Shameful category.
==Commands==
There is only 1 command: shame, which prints out You should be ashamed of your self. and a line feed.
==Examples==
===Quine===
 You should be ashamed of your self.
===Quine 2===
You should be ashamed of your self.
You should be ashamed of your self.
Category:Languages
Category:Joke languages
Category:Output only
Category:Unusable for programming
Category:Total
Category:2023
Category:Unimplemented
Shape-Machine

A Shape-Machine is an example created by User:Ractangle where firstly it just adds 3 to variable a/input and then multiply it by 0.86, then prints the variable, and loop it over and over again.
Each number will get closer to 18.(428571) after each iteration of addition and multiplication.
==Pseudocode==
 a = input
 repeat forever {
 a = 0.86 * (a + 3)
 output(a)
 }
==Implementations==
===Python3===
 a=int(input())
 while 1:print(a:=(a+3)*0.86)
===><>===
 i>3+819+,619+19+*,+*v
 ^ o+19n:<
===AsciiDots===
 .
 |
 #
 ?
 v--------------------\
 *----$#-{+}----{*}-$#/
 *-#3-----/ |
 *-#8----{/}-{+}-/
 *-#10----/ |
 *-#6----{/}--/
 >-#100---/
===MoreMathRPN===
 inputR
 3
 +
 0.86
 *
 >> 0
 outputV
 outputS ", "
 jmp -7
===Huit===
 (shape)<'&3+&0.86*:>[shape]
==External resources==
* Desmos interactive graph of this as a function.
Category:Program forms
Shard

"Heard them mention... the Shard."
 - Merc's last words
Shard was created with the purpose of being hard to program in. Many have claimed to create such languages, but in reality they confuse hardness with mere inconvenience, while Shard is actually hard.
== Language overview ==
A Shard compiler takes a source code, calculates the SHA256 hashcode of each line individually, and then concatenates the hashes into a binary executable. Therefore, to program in Shard, one effectively needs a preimage attack on SHA.
== Computational class ==
Extremely likely to be Turing-complete, although I have no proof.
== Background ==
Shard, a blend word of SHA and hard, was created by User:$M@ in 2016. Not to be confused with shart.
It has been pointed out to me that this language is basically a ShaFuck derivative.
Category:2016
Category:Joke languages
Sharp flat

#b is a Brainfuck-equivalent esolang created by User:None1.
==Why is it named #b==
In music, there are two signs, sharp (#) and flat (b).
# has an odd ASCII value, while b has an even ASCII value, that's the trick.
In #b, all characters with an odd ASCII value is treated as #, and all characters (except line feed) with an even ASCII value is treated as b.
==Execution==
Every character (except line feed) in a #b program can be treated as # and b, and Brainfuck has 8 opcodes. Because 2**3=8, three characters make a brainfuck opcode, remaining characters are ignored.
Here is the #b to Brainfuck conversion table:
#b Brainfuck
bbb +
bb# >
b#b ,
#bb [
b## ]
#b# .
##b <
### -
==Example Programs==
Hello World:
bbbbbbbbbbbbbbbbbbbbbbbb#bbbb#bbbbbbbbbbbbbbbbbbbbbbbb##b###b##bb#bbbbbbbbbbbbbbbbbbbbb
bbb#b#bb#bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb#bbbb#bbbbbbbbbbbbbbbbbbbbbbbb##b###b##bb#
bbbbbbbbbbbbbbb#b#bbbbbbbbbbbbbbbbbbbbb#b##b#bbbbbbbbb#b#bb#bbbbbbbbbbbb#bbbb#bbbbbbbbb
bbbbbbbbbbbbbbb##b###b##bb##b###b##b##b##bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
#b#bb#bb##b#bbbbbbbbb#b####################b##########################b#bb#bb#bbb#b#
Or, if you wanna be crazy:
NjzDrpXLZldbvdZVNxdDDrHzILfHtcvjPvPlhpJHxjrDHJLHzfNRzNASjmYIhyIjDqZzPdVfHJdXppHdTLXhxjd
JjFaVodHgfxBBJzbxPBzbFDnpDTjzbRhhLvlbxRtzDlrVKvjXBetbzFBxTTlTvRXPZnlnFhzjVfiiFQMePAwdbI
XXFDxjZNfpBnblPOnWjtRXLdBhtDnXJHTVrtpdxMnWAncXjTlBXJZfuFIVbcrXbvDltLLnpDADnZBAJPzrxzHVl
vntjTJXZLtBnHnRkmZkskhsqJxSQfgMMnGwDQuPwQNPVpDxXDZXBtdRVNZBtRhffPzvvVzLVZFbzjrhdLnpnpDF
srEpTydNaQzMZtRnNbdpByncyUWGKOSkukeUCWagqGYRAEwQemEYuGUSoCMWWMSmIGWcgaLoVnoZXETTFcnm
Cat program:
 bbb#bbb#b#b#b##
Or, if you wanna be crazy:
 dXzyHhtQVCfMFAS
Self documenting:
 Rypet in_put!!
Reverse one line of input:
 bb#bbb#bbbb#bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb#b##############################b####b#bb##bb##bb####bb##bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb#b####b#bb#b###bb##
Or, if you wanna be crazy:
 PpyTPLmbxtRybhnFFvRPPXRtJTrpbnzBrrBRTBThLnBmlYaagwskuuEEQYGcyawSWwAemesWUgOlAoCyRaTfKwNJuShNWSmeLLsabvTjbHLNrnhDhHPfxZrHHJdPbnnNLlLNvVixAcwajIrdMZSsAvdsA
Truth Machine:
 b#bbb#bbbbbbbbbbbbbbbbbb#bb##b########################bb####b####b#bbbb#bbbbb
 bbbbbbbbbbbbb#bb##bbbbbbbbbbbbbbbbbbbbbbbbbbb####b####b#bb#b#b##b##bbbbbbbbbbbbbbbb
 bb#bb##bbbbbbbbbbbbbbbbbbbbbbbbbbb####b####b#b#
Or, if you wanna be crazy:
 VAzVDsfjrdNPhxlZfjFvVhlZWZvqIDWAAsAOgMWwqOokmugIwoIYGaZheWYivOWkAnqppnxudlnjF
 BPHppjXXrzxJVYNtqKFZBBDVzlDDbFrZPfJrlFdZfbzJvOGkahwESOlGzFSVaJkGzAixnXdbHbNtjhlvbVR
 vVwTPAszXTnBBblXBrpNvbdJhzhrtLjPzjwcuqdgkocJeJq
==Interpreter==
* Common Lisp implementation of the #b programming language.
* An interpreter in Python written by the author of this language (User:None1).
Category:Brainfuck equivalents
Category:Languages
Category:Cell-based
Category:2023
Category:Implemented
Sharp flat Python interpreter

← Back to #b
The following program is an interpreter written in Python for #b (a.k.a. Sharp flat), by the author of that esolang (User:None1).
import sys
def bf(code):
 s1=[]
 s2=[]
 matches={}
 tape=[0]*1000000
 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
def sf(code):
 b=''
 d={'bbb': '+', 'bb#': '>', 'b#b': ',', '#bb': '[', 'b##': ']', '#b#': '.', '##b': '<', '###': '-'}
 code=.join(list(filter(lambda x:x!='\n',code)))
 for i in range(len(code)//3):
 s=.join([('#' if ord(code[3*i+j])%2 else 'b') for j in range(3)])
 b+=d[s]
 bf(b)
sf(sys.stdin.read())
Category:Implementations
Shatner

Shatner is an esolang created by User:occular.
== History ==
The language was conceived in May 2016, as a possible answer to the question "How could I embody the spirit of William Shatner in a programming language?", and inspired by the conception of the ShatnerSort algorithms, invented in the 1990s by Alex Hunsley and Nick Walton.
== Description ==
A Shatner program has two parts:
* A collection of training inputs and outputs
* The main inputs
An example source file for Shatner:
 1,10
 10,100
 11,110
 1000
 1100
Each line containing a comma is a pair of training inputs: a binary input followed by a binary output. These are example transformations from input to output for an algorithm that Shatner will try to derive. (In this case, it's binary multiplication by 2.)
The lines without a comma are inputs that Shatner will run through its derived algorithm (should it ever find one that passes all the input/output examples).
== Implementing Shatner ==
Starting at 0, for each positive integer: Convert to base 8. Interpret this base 8 number as a string of Brainfuck commands, as follows:
 > 0
 < 1
 + 2
 - 3
 . 4
 , 5
 [ 6
 ] 7
Execute this Brainfuck program using all the training inputs in turn. If any training input does not produce the corresponding expected training output, move onto the next integer. If the Brainfuck program doesn't exit after 60 seconds on any input, stop executing it and consider the training input as failed.
If all the training inputs produce the expected training outputs for an integer N, run the found algorithm on the main inputs, sending the outputs to the terminal.
Sheep

== About ==
Sheep is a functional esolang where the only datatype is lambda functions. It was invented by constantly simplifying and reducing another language idea, however it essentially became lambda calculus with prefix notation.
== Overview ==
A Sheep program is a list of constant definitions written in the form name value;.
The name of an identifier is any number of non-whitespace characters except for /, ., and ;.
A value is one of three things:
* A named constant/variable reference. name.
* A lambda declaration. \ name value.
* A lambda call. . lambda value. (lambda is another value here)
All lambdas take exactly one parameter, but you may use currying to simulate multiple.
== Small Notes ==
* Comments begin with //.
* Whitespace only matters to separate identifiers when needed, it is otherwise ignored.
* The constant main will be called with the program input, and its return value is the output.
* A variable reference will always use the innermost scope. (ie: Variable Shadowing)
== IO Format ==
The main constant will be called with the program's input, ie: . code input is the initial call.
The program input and output are both strings that are converted into nested lambdas.
Suppose our program input is abc, we first convert it into a UTF-8 bitstring: 011000010110001001100011. We then place a 1 before each bit, and pad it with infinite zeroes: 1011111010101011101111101010111010111110101011110000...
To continue, it will be helpful to define two functions:
1 \x \y x; // Takes two args, returns the first.
0 \x \y y; // Takes two args, returns the second.
Our format will resemble a LinkedList where passing 1 into it will return its bit, and 0 will return the rest of the bits. (ie: head and tail). We can write a single node using the following template expression: \bool . . bool if1 if0.
Applying the expression to the format, we get the following: \bool . . bool 1 (rest). Where (rest) would be another copy of this expression, but returning 0 instead (see above bitstring).
Suppose we have the bitstring 101 (This is impossible in practice), we can write it like so:
\b ..b 1
\b ..b 0
\b ..b 1
(infinite zeroes)
Note that these aren't separate statements, they're chained together via the first . on each line.
Finally, (infinite zeroes) can be defined as: infiniteZeroes \b ..b 0 infiniteZeroes.
(Note: This can be written with a raw expression, it does not internally use a constant, but it improves readability)
So, in total, 101 becomes: \b..b 1 \b..b 0 \b..b 1 infiniteZeroes, or written without any constants: \i..i\1\0 1\i..i\1\0 1\i..i\1\0 1\i..i\1\0 0.\x\b..b\1\0 0.x x\x\b..b\1\0 0.x x;
The opposite process is done to parse an output back into a string.
== Examples ==
SKI Combinators, proving Turing-Completeness
S\x\y\z . . x z . x y;
K\x\y y;
I\x x;
Cat program.
main \x x;
Church numeral encoding.
0c \x x;
++ \n \x . n . x x;
Category:Languages
Category:Turing complete
Category:Unimplemented
Category:2023
Category:Functional paradigm‏‎
Shelta

Shelta is a language designed and implemented by Chris Pressey in 1999. Shelta was designed as a successor to Maentwrog. It is a low-level language inspired by Forth, False and assembly language.
Shelta was designed to be minimalistic: a Shelta-to-8086 compiler was implemented in 512 bytes of 8086 code. (A version of this compiler was also subsequently written in Shelta, and bootstrapped.) Shelta is so minimalistic, in fact, that by itself it cannot express very much beyond names and their relationships. It relies on inline machine code to perform computations.
==External resources==
*
*Shelta assembler/compiler on Codeberg
Category:Languages
Category:Implemented
Category:Low-level
Category:1999
ShiftbB

ShiftbB (meaning "Shift bit Byte") is a cell-based esoteric programming language that uses 2 data units without explicit types: bits and bytes. The move pointer instructions are bit-sized and most of the other instructions are byte sized. The current byte is from your_position to your_position+8. Because there are no proper increment/decrement operators, setting a value involves manually setting the bits, and an "overflow region" where any extra data is destroyed.
== Instructions ==
Instruction	Scope 	Action
, 	Bit 	Decrement instruction pointer
. 	Bit 	Increment instruction pointer
1 	Byte 	Sets the current byte to 0x00
2 	Byte 	Sets the current byte to 0xff
_ 	Byte*2	Print operator. Prints previous byte as ASCII char if current byte is 0x00, prints previous byte as hex value if current byte is 0xff
/ 	N/A 	Ends the program. Programs without this as the last instruction are undefined, and will segfault on the reference implementation
@ 	Byte 	Sets the current position as the return, and sets the current byte as the left operand for a comparison
= 	Byte 	If current left operand == current byte, return to return
? 	Byte 	Sets current byte to user input
== Examples ==
=== Hello World ===
 1.2.1..2.1...1_.2..1..2.1.2.1_.2..1.2..1..1_.2..1.2..1..1_.2..1.2....1_..2.1.2..1..1_..2.1.....1_.2.1.2.1.2...1_.2..1.2....1_.2...1..2.1.1_.2..1.2..1..1_.2..1..2.1..1_..2.1....2.1_/
=== Cat ===
This implementation only allows 1 char at a time.
 ?........1_/
=== Truth Machine ===
If input is 1, loop. Else, halt.
 ?@........1_,,,,,,,,1..2..1...2,,,,,,,=/
== Implementation ==
Reference implementation is at https://gitlab.com/KSPAtlas/shiftbb
Category:2021
Category:Cell-based
Category:Implemented
Category:Low-level
Shifty

Shifty is an esoteric assembly language created by User:D. The primary operation is bit shifting.
== Instructions ==
There are two unbounded registers, A and B.
* SLB: Set lowest bit of A to 1.
* LSH: Left shift A by 1 bit.
* RSK x: Right shift A (storing parity). If parity == 0, skip forward x instructions.
* SKZ x: If A == 0: Skip forward x instructions.
* XCH Exchange A and B.
* BR x: Unconditionally branch back x instructions.
== Examples ==
=== Cyclic tag system simulator ===
; Cyclic tag simulator
 SLB
rules:
rule_1:
 RSK end_1
; Move everything from A to B;
; (reversing bit order)
copy_1:
 SKZ end_copy_1
 XCH
 LSH
 XCH
 RSK skip_bit_1
 XCH
 SLB
 XCH
skip_bit_1:
 BR copy_1
end_copy_1:
; Production 1: 011
; (store it in reverse bit order)
 SLB
 LSH
 SLB
 LSH
; Move everything from B to A (still reversing bit order)
 XCH
second_copy_1:
 SKZ end_second_copy_1
 XCH
 LSH
 XCH
 RSK second_skip_bit_1
 XCH
 SLB
 XCH
second_skip_bit_1:
 BR second_copy_1
end_second_copy_1:
end_1:
 ; Same logic for other productions
 ; ...
 ; Jump back to start
 BR rules
Category:Languages
Category:2023
Category:Low-level
Category:Turing complete