nyuuzyou/wikis huggingface dataset:
Seabass

Seabass is a programming language that was inspired by Deadfish and is backwards-compatible with it. The other key points of Seabass are:
* functionality
* (relative) ease of use
The language has about 30 commands, each is a single letter - uppercase or lowercase. Typically lowercase commands use one variable, while uppercase use two, these variables are located in the accumulator and deccumulator. Accumulator and deccumulator are identical in structure - infinite tapes with zeroes in all cells, but they act differently for each command. In order to operate with other data types, you have to access the Extended Stack, which is also an infinite tape with zeroes in all cells, but it can store all four data types, strings included. Variable names can only be integers, same is true for functions(k>) and goto points(: or ;).
==Examples==
===Hello, world!===
iisibCmbCZbmbbCZbmbbbCZbmbbbbCbcazZZxaxzcaxziibIIIIbIIZTaxzcaxzibbIIIIZTaxzcaxziiibIbIIIIZTaxzcaxziiibIbIIIIZTaxzcaxzibIIbIIIIZTaxzcaxziibIbIZTaxzcaxziibIIbIIIZTaxzcaxzibIIbIIIIZTaxzcaxziiiibIIbIIIIZTaxzcaxziiibIbIIIIZTaxzcaxzbbIIIIZTaxzcaxziiibIbIZTzZaCaczcOzZaCaczc
This example was compiled from Tsb.
===Cat===
 iisiiisiiiiiiiiiiiiiTaiQO
===Truth-machine===
 ixqxa:z{aioj>.ao>
Or, alternatively:
 ixaibxaq!@>.b:oj>
=== Infinite loop ===
 i:j
==External resources==
* Interpreter source code
* Seabass documentation
* Interpreter readme
Category:Languages
Category:Implemented
Searchfuck

Searchfuck is a brainfuck equivalent with all commands being the most common google searches.
== Commands ==
Searchfuck 	Brainfuck
youtube 	>
facebook 	<
whatsapp web	+
google 	-
gmail 	.
amazon 	,
translate 	[
traductor 	]
Category:Joke languages
Category:2022
Category:Brainfuck equivalents
Category:Languages
Category:Unimplemented
Category:Thematic
Category:Turing complete
Category:Turing tarpits
Category:Cell-based
Category:Low-level
Category:Pseudonatural
Category:Brainfuck derivatives
Seas

Seas is a 2D esoteric programming language made by User:AmNow and was made for TeamSeas.
== Commands ==
The memory field is an infinite sea with the instruction pointer at 0,0 and moves rightward.
 🌊🌊🌊🌊
 🔳🟦🟦🟦
 🟦🟦🟦🟦
Everything outside of a written program is initialized with a space or a random character from the printable ASCII range with a ⅕ chance. Program execution ends when the instruction pointer reaches the top of the sea.
Every line must be the length of the first one. The first line can only have 🌊 (whitespace not allowed).
 🟦 - NOP.
 🌊 - Ends the program, this can only be at the first line.
 0️⃣ through 9️⃣ - Push the corresponding digit to the stack.
 🅿️ - Pop the top two values on the stack and locate the coordinates in the sea and swap it with the accumulator.
 🧾 - Swap the top of the stack with the accumulator.
 🌡 - Set the accumulator to 0.
 🔑 - Clear the entire stack.
 🖍 - Reverse the stack.
 📗 - Move the bottom-most element up to the top.
 📙 - Move the top element to the bottom.
 🖋✒️ - Mirrors.
 📍 - Pop the top value of the stack, if it is 0, move up, otherwise move down.
 📏 - Pop the top value of the stack, if it is 0, move left, otherwise move right.
 ➕➖✖️➗ - Add, Subtract, Multiply and divide on the stack.
 🔼🔽◀️▶️ - Rotate the instruction pointer to match which way it is facing.
 💡- Input a number and push it.
 📖 - Input a Unicode Character and push it.
 🗳 - Pop the top value and output as a number.
 📅 - Pop the top value and output as a Unicode Character.
 ✉️ - Pop and discard.
 ✂️ - Swap.
 🧻 - Duplicate.
 🥤 - Logical NOT the top of the stack.
== Programs ==
=== Truth-Machine ===
 🌊🌊🌊🌊🌊🌊🌊
 💡🔽🗳🟦🟦🟦🟦
 🟦▶️📍🟦🟦🟦🟦 
 🟦🟦▶️1️⃣🗳1️⃣◀️
==Computational class==
Seas, according to its creator, is probably turing complete. But no proof of its turing completeness exists.
It is likely that the language can simulate the infinite tape of the Brainfuck language by using the "Reverse the stack" and the accumulator to rotate the stack around. However, the Turing-completeness is still not confirmed yet. [citation needed]
Category:LanguagesCategory:2021Category:Two-dimensional languagesCategory:UnimplementedCategory:Unknown_computational_class
Second Airline Food Turing-completeness Proof

lets begin all programs with
 u ever notice 1
for 60001 variables zero em
 whats the deal with tapecell
 not like tapecell
when the pointer moves left this happens
 lets talk about tapecell60001
 not like tapecell60001
 it's kinda like tapecell60000
 lets talk about tapecell60000
 not like tapecell60000
 it's kinda like tapecell59999
 ...
 similar when the pointer moves right
inc and dec from Airline Food Turing-completeness Proof are used here for + and - respectivly
while and endwhile from Airline Food Turing-completeness Proof are used for [ and ] respectivly
 right? 
and
 see? 
are used for , and . respectivly
category:proofs
Secretary

Secretary is an esoteric programing language created by user User:Wingpad in 2013. It was designed to be run by a secretary at their desk. Its premise is that a secretary is reading your program as an instruction book. In addition, it can conveniently be interpreted by a computer. It features multiple programming models including an array of memory cells, push-down automata and support for primitive function calls. It is Turing-complete since it can interpret Brainf**k.
===Humor===
If an instruction is given in ALL CAPS, there is a 50% chance the secretary will be offended and ignore it completely. It will not, however, ignore bookmarks given in all caps.
===Sample Programs===
A cat program which stops at 0
open book
take from incoming
bookmark loop
toss into outgoing
take from incoming
if nonzero then turn to loop
close book
A Hello, World! program that dumps the string onto the stack
open book
remark Toss the starting zero onto the pile
toss onto pile
remark Toss Hello, World! onto the stack
make 10
toss onto pile
make '!'
toss onto pile
make 'd'
toss onto pile
make 'l'
toss onto pile
make 'r'
toss onto pile
make 'o'
toss onto pile
make 'w'
toss onto pile
make ' '
toss onto pile
make ','
toss onto pile
make 'o'
toss onto pile
make 'l'
toss onto pile
make 'l'
toss onto pile
make 'e'
toss onto pile
make 'H'
toss onto pile
take off pile
remark Here is where the program starts
bookmark start
remark Toss whatever is in your hand onto the outgoing
toss onto outgoing
remark And take the next character off the string
take off pile
remark If the character is not zero, loop back to the start bookmark
if nonzero then turn to start
close book
A primitive function call example (will print 30\n)
open book
make 10
toss onto pile
make 20
toss onto pile
call add
take off pile
toss into outgoing as int
make 10
toss into outgoing
close book
remark Adds the two numbers on top of the pile (lpile)
remark Destroys Immed and cannot handle negatives
bookmark add
take off lpile
toss onto rpile
bookmark addLoop
take off lpile
subtract
toss onto lpile
take off rpile
add
toss onto rpile
copy from lpile
if nonzero then turn to addLoop
take off rpile
toss onto lpile
hang up
===External resources===
* Original Site w/ Interpreter, Sample Code and Definitions
* Brainf**k to Secretary Converter
Category:Languages
Category:Cell-based
Category:Stack-based
Category:2013
Category:Implemented
Category:Turing_complete
Sectorlisp

Sectorlisp is a tiny lisp interpreter written by Justine Tunney. It consists of a tiny x86_16 interpreter running on IBM PC that interprets a smaller subset of lisp, and this runs a tiny lisp interpreter written in lisp that is closely derived from a lisp interpreter published by John McCarthy in 1960. The values handled by the interpreter are symbols and garbage-collected immutable cons cells. The interpreter contains a parser (reader) and printer for lisp values (nested lists) made of these.
== External links ==
* Github repository with source code for sectorlisp
Category:2020
Category:Implementations
SeedFuck

SeedFuck is an esolang invented by User:None1, it is seed but for brainfuck.
Programs are like this:
 <length> <seed>
==Random Generator==
SeedFuck uses Python 3.11's random generator, it generates numbers within [0,8)∩Z inclusive and translates the numbers into brainfuck code. For more information, see implementation.
==Transpiler in Python from SeedFuck to brainfuck==
from random import *
k,l=list(map(int,input().split()));seed(l)
for i in range(k):print('+-,.[]><'[randint(0,7)],end=)
==Examples==
==9 bytes :I interpreter==
 1 1
Brainfuck equivalent: 
==APLWSI interpreter==
 0 0
Or:
 2 2
Brainfuck equivalent: 
Category:Languages
Category:Joke languages
Category:2025
Category:Implemented
Category:Brainfuck derivatives
Segfuck

Segfuck is a variant of brainfuck which encourages frequent segmentation faults.
== Language Overview ==
Segfuck operates on an unbounded array of uninitialized memory cells of machine word size.
Command	Description
> 	Move the pointer to the right.
< 	Move the pointer to the left.
0 	Store the value 0 in the memory cell at the pointer.
+ 	Increment the memory cell at the pointer.
- 	Decrement the memory cell at the pointer.
. 	Output the character signified by the cell at the pointer.
, 	Input a character and store it in the cell at the pointer.
^ 	Set the address of the pointer to the value in the cell at the pointer.
! 	If the cell at the pointer is not 0, segfault. 
Otherwise, if the cell at the pointer is integer n, jump to the nth instruction.
? 	If the cell at the pointer is not 0, do nothing. 
Otherwise, if the cell at the pointer is integer n, jump to the nth instruction.
Category:2023
Category:Brainfuck derivatives
Category:Unimplemented
Category:Unknown computational class
Segmentation Fault

Segmentation Fault is a programming language made by Not_applicable. It has only one valid program:
Segmentation fault
And that prints "Hello, World!". Any other program throws a syntax error:
Syntax eror
and it immediately destroys both the interpreter and the file containing the program.
= Sample programs =
== Hello, World! ==
Segmentation fault
== Quine ==
Syntax eror
= Interpreter =
There is an interpreter written in bash:
if [ $# = "1" ]
then
read Program < "$1"
if [ "$Program" = "Segmentation fault" ]
then
echo "Hello, World!"
exit
fi
fi
echo "Syntax eror"
rm "$0"
rm "$1"
Another interpreter in Python:
import sys,os
program=sys.argv[1]
with open(program,'r') as f:
 code=f.read()
if code=='Segmentation fault':
 print("Hello World!")
else:
 print("Syntax eror")
 os.remove(sys.argv[0])
 os.remove(program)
== See also ==
* C
Category:2020
Category:Zero-dimensional
Category:Unusable for programming
Category:Implemented
Segmentation fault

Segmentation fault is Nope. but every "Nope." is changed with a segmentation fault.
==Implementation==
===C===
 #include <stdio.h>
 int main(void)
 {
 	scanf("");
 	char *s = "no use lol";
 	*s = 'H';
 }
===Pascal===
 function nope(x: int8): int8;
 begin
 nope(0);
 end;
 
 begin
 readln();
 nope(0);
 end.
===Python===
 import ctypes
 a=input()
 if a==a: ctypes.string_at(0)
Category:Unusable for programming
Category:Joke languages
Category:2021
Category:Implemented
Category:Nope. derivatives
Category:No-code esolang
Category: Languages
Segreq

Segreq (SEcond GRade EQuation) is a language created in 2020 by User:Hanzlu.
The language operates on a row of cells and a stack. The commands in the language are second grade polynomials.
Interpreter exists in Python here .
Commands are written as second grade polynomials of the form ax^2+bx+c where a, b and c are numbers and + characters can be either + or -. Second grade polynomials represent a number which is the solutions of ax^2+bx+c = 0 added together. For example the solutions of the equation 1x^2+0x-1 = 0 are x=-1 and x=1. Thus, if 1x^2+0x-1 is used as a command it will represent the number (-1+1=0) 0. Notice that even if b = 0 in the latest polynomial it must be written out. Each polynomial's last character is a comma (,) to separate them, even the last polynomial has a comma.
In order to have arguments for operations, the a value in a polynomial ax^2+bx+c is used as argument. For example, when a cell is set to be equal to a number, a will be the number the cell becomes equal to. Whenever the top value of the stack is used it is popped from the stack. If statement cannot be nested and there are no else statements.
In order to limit the use of the same polynomial over and over again, certain commands are represented by different numbers (polynomials) at different hours. Code written between 7 and 8 AM will not work the same between 1 and 2 PM. The current hour is in fact used as a seed to randomize 20 numbers, since there are 20 valid operations in Segreq. For example, the random numbers when he clock is between 14:00 - 14:59 are: (-19, 18, -14, -18, -13, -9, 4, -10, 11, 3, -8, -11, 5, 14, -17, 8, -7, -5, 15, -12). The command output a character is always represented by the second number in that list, so when the hour is 14, the output command happens to be represented by the number 18. So, in order to output a character when the hour is 14, the polynomials solutions must add up to 18.
Here is a list of the command in their order from 1-20:
Command	Explanation
1 	Sets the cell equal to a.
2 	Outputs the cell as an ASCII character.
3 	Moves the pointer to the left.
4 	Moves the pointer to the right.
5 	Pushes the value in the cell onto the stack.
6 	Pops the top value of the stack into the cell.
7 	Lets the user input a number into the cell.
8 	Cell is increased by the top value of the stack.
9 	Cell is decreased by the top value of the stack.
10 	Cell is multiplied by the top value of the stack.
11 	Cell is divided and floored by the top value of the stack.
12 	Cell is modulus by the top value of the stack.
13 	Cell is raised to the power of the top value of the stack.
14 	If cell is not equal to the value of the top stack, the code reader jumps to the next ;
15 	If cell is larger than the value of the top stack, the code reader jumps to the next ;
16 	If cell is less than the value of the top stack, the code reader jump to the next ;
17 	Pointer is moved to cell <a> (a as argument).
18 	Jumps to polynomial number <a> (a as argument).
19 	Cell is set equal to a random number between 0 and <a> (a as argument)
20 	Program is halted.
CAT
 1x^2-4x+0, 1x^2-18x+0, 1x^2+5x+0,
Self

There is one command, Self, which prints "Self"
== Self program ==
 Self
== Quine ==
 Self
== Quine 100 ==
 Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self Self
== Interpreter ==
 #python
 def Self(program):
 for command in program.split(" "):
 if command == "Self":
 print("Self")
 else:
 raise NameError("Only recognizable command is 'Self', but got '"+command+"'!")
== Other Selfs ==
* Self 2
* Self but with loops
Category:Languages Category:Joke languages Category:Pseudonatural Category:Output only Category:Unusable for programming Category:Total Category:Implemented
Self%ify

==SELF%IFY...==
Is unique because the source, STDIN, and STDOUT are all the same, however, this does not remove any abilities, and if anything, actually adds to the abilities of the language
Symbol 	Args 	Action
% 	NONE 	terminates program
+ - * / ~	A B 	math with A and B (~ is modulo)
: 	A 	appends A to the file
; 	NONE 	removes the last char in file
` 	X Y 	goes to (X, Y)
' 	X 	`, but the file is treated as a 1D array (V. 2D)
? 	A 	prepends A to the stack (shifts stack to right)
\ 	A B 	appends B A (swaps top two value)
( 	NONE 	makes a new stack (old one IS kept)
G 	NONE 	gets the top of the OLD stack and puts it on the current one (created with ()
) 	NONE 	deletes current stack (created with () and puts it on old stack
< = > 	A B 	compares A and B
[ ] 	NONE 	while(TOS != 0) loop
{ } 	NONE 	while TOS == 0) loop
^ 	X Y 	appends value at (X, Y) to stack
& 	X Y V	value at (X, Y) = V
$ 	X 	^, but the file is treated as a 1D array
@ 	X V 	&, but the file is treated as a 1D array
! 	NONE 	skips next command
# 	V 	the next char becomes V
" 	NONE 	appends all chars encountered ASCII value until another " is met
--Super Mario Man (talk) 17:25, 6 April 2021 (UTC)
Category:Languages Category:Stack-based
Self-Recursive Brainfuck

Self-Recursive Brainfuck is a joke derivative of 8-bit Brainfuck (Brainfuck where every cell can have 256 values) by Larho#9031 with an extra # instruction that transforms cells into self-referencing programs. Since Self-Recursive Brainfuck does not modify existing commands at all, any program that can be run in Brainfuck can also be run in Self-Recursive Brainfuck.
== Instructions ==
The table below are the instructions for when the pointer is not on a program cell.
 
Instruction	Meaning
+ 	Increment the value at the pointer
- 	Decrement the value at the pointer
< 	Move the pointer to the right 1 space
> 	Move the pointer to the left 1 space
[ 	If the value at the current cell is 0, jump to the matching ]
] 	If the value at the current cell isn't 0, jump back to the matching [
. 	Print the current cell's value as an ASCII character
, 	Accept one byte of input from the user and store the byte in the current cell
# 	Transform the current cell on the pointer into a self-referencing program. Data on the cell is not preserved.
The table below are the instructions for when the pointer is on a program cell.
 
Instructions	Meaning
+ 	Does nothing
- 	Does nothing
< 	Move the pointer to the left 1 space
> 	Move the pointer to the right 1 space
[ 	Jump to the matching ]
] 	Does nothing
. 	Print the program's source code
, 	Take the user's input and add it to the program
# 	Transform the current program cell into a normal cell again and sets the value in it to 0
== Examples ==
=== Quine ===
#.
=== Hello, World! ===
-[------->+<]>-.-[->+++++<]>++.+++++++..+++.[->+++++<]>+.------------.---[->+++<]>.-[--->+<]>---.+++.------.--------.-[--->+<]>.
=== Cat ===
,+[-.,+]
== Implementations ==
This is an implementation of Self-Recursive Brainfuck in Self-Recursive Brainfuck:
#,>----------[++++++++++<,---------->][-]<#
It takes input until you press the Enter key then executes the code.
Category:Languages Category:2021 Category:Cell-based Category:Turing_complete Category:Brainfuck_derivatives Category:Low-level
Self-interpreter

A self-interpreter is an interpreter written in the same language that it interprets. It may be metacircular.
== Metacircular interpreters ==
An interpreter may be homoiconic, and it may use homoiconicity to represent its code as data. In this situation, the interpreter is called metacircular. In a metacircular interpreter, some interpreter operations are not implemented as interpreter behaviors, but by reusing behaviors of the host language. When an operation is not implemented, but passed through to the underlying host runtime, then the operation is absorbed by the interpreter. If instead the interpreter implements behaviors without reusing the host runtime, then the interpreter reifies the operation.
Non-metacircular interpreters can consider the question of whether to absorb or reify a particular behavior, too, but in a certain sense, non-homoiconic languages cannot absorb most behaviors.
== Folklore ==
It used to be believed that self-interpreters only exist for languages that are sufficiently complex. Any Turing-complete language admits a self-interpreter. In contrast, legends claim that if a lambda calculus is strongly normalizing, then it cannot admit a self-interpreter. However, in , it is claimed that System Fω admits a self-interpreter.
It is, of course, trivial to design a language that is Turing-incomplete but capable of self-interpreting via adding a specific "self-interpreter" instruction, in the style of HQ9+. (That's InterpretMe)
== Languages known for self-interpretation ==
* Prolog
* Subleq and other OISCs (multiple self-interpreters for it exist)
* brainfuck
* InterpretMe
== See also ==
* wiktionary:self-interpreter
Category:Concepts
Self-modifying Brainfuck

Self-modifying Brainfuck, also known as SMBF, is a variant of brainfuck by Simon Howard, which allows a program to modify its own source code. The program code is placed in the data array, and the data pointer starts at the byte immediately after the last instruction in the code.
==Language overview==
SMBF operates on an array of memory cells, also referred to as the tape, each initially set to zero. There is a pointer, initially pointing to the first memory cell. The commands are:
Command	Description
+ 	Increment the memory cell under the pointer
- 	Decrement the memory cell under the pointer
> 	Move the pointer to the right
< 	Move the pointer to the left
. 	Output the character signified by the cell at the pointer
, 	Input a character and store it in the cell at the pointer
[ 	Jump past the matching ] if the cell under the pointer is 0
] 	Jump back to the matching [ if the cell under the pointer is nonzero
All characters other than ><+-.,[] are ignored if executed but may be accessed, modified, or printed as part of the source code on the tape.
==Examples==
This prints Hello, World! :
 <[.<][0!dlroW ,olleH]
This will print 1 only in the Python interpreter (otherwise nothing), because it dynamically creates code on the tape outside of the initial program code:
 >>++++++[<<++++++++++>++++++++>-]<--<1
This is a quine. It will print it's own source code:
 <[<]>[.>]Quines are easy!
It will print it's own source code:
 <[<]0>[.>]
==See also==
* Brian & Chuck, which is similar but has two mutually modifying brainfuck-like programs.
==External resources==
* Home page with implementation
* Online interpreter from original implementation
* Python interpreter by User:mbomb007. Executes dynamic code, unlike the original interpreters.
Category:Implemented Category:Languages Category:Brainfuck derivatives Category:Low-level Category:Turing complete Category:Cell-based Category:Self-modifying Category:2006 Category:Turing tarpits
Self-modifying BrianPh*ck

Self-modifying BrianPh*ck is a joke language by User:Orisphera.
==Commands==
Self-modifying BrianPh*ck has the following commands:
Command	Description
> 	Skip the next instruction
< 	Go into an infinite loop
+ 	Put a , instead of the +
- 	Put a , instead of the -
. 	Output a dot
, 	Input a character and put it instead of the ,
[ 	Do nothing; used as a destination for ]
] 	Jump back to the matching [
Anything else is a no-op. If a > has one after it, it skips only the no-op, so
 >_<
is an infinite loop, just like
 >.<
is, although
 ><
isn't.
==Examples==
Quine:
 .
(or any other program consisting only of .'s
Infinite loop:
 <
or
 []
Conditional infinite loop:
 [,]
If the first input other than +, -, or , is >, it halts; if it's ., it outputs infinite dots; if it's ], it crashes; otherwise, it goes into an infinite loop.
Category:2023 Category:Unknown computational class Category:Unimplemented Category:Joke languages