nyuuzyou/wikis huggingface dataset:
Potatoscript

potatoscript is an esoteric programming language based on single-character commands, made by nanobot567.
==General information==
potatoscript is coded in Python 3.9. Its parser does not use the usual methods of creating a programming language, such as using a lexer and tokenization, but instead uses a for loop to check each character in the file, and as it does so, performs the specified actions accordingly.
==Programming==
===Basics===
A potatoscript only requires that there be a beginning and end indicator in the file for it to be valid. Tildes are these indicators. For example, the following code can be executed with no errors:
 ~
Most commands in potatoscript do not have any specific syntax, but there are exceptions. One is the print start indicator (-), which requires an end indicator before the end of the script.
===Example potatoscripts===
This potatoscript is the classic hello, world program:
 ~-Hello world!_~
This prints "Hello", a newline, then "there":
 ~-Hello_/-there_~
This gets input from the user and prints it:
 ~-Input:_#-You typed_$~
===Indicators (commands)===
*"~" - start and end script
*"-" - print start
*"_" - print end
*"/" - newline
*"#" - get input and store it
*"$" - print the stored string
*"*" - reset the stored number
*"+" - add one to the stored number
*"`" - subtract one from the stored number
*">" - multiply the stored number by the integer specified
*"&" - divide the stored number by the integer specified
*"^" - print the stored number
*"@" - sleep for the integer after the indicator
*"%" - alt version of the indicator
===Alt commands===
 +, -, >, & (math indicators)
depending on how you use %, these indicators can do different things.
if % is behind an integer and is in front of a math indicator, the stored number is increased, decreased, multiplied, or divided by that integer, depending on which indicator you use.
if not, the stored number is increased, decreased, multiplied, or divided by 5.
NOTE: the integer to be used can only be 1 character long for the operation to work as expected.
 _ (print end)
if % is in front of _, the string printed has no newline printed at the end.
 # (get input)
if % is used, the input gathered from the user is stored as an integer.
if the input statement looks like the following: #%!, then the input will be appended to the stored string.
==Limitations==
For all of the math indicators, only integers with a length of 1 are accepted.
==External Resources==
* potscr on Github - Open-source potatoscript parser
* potatoscript on github.io - Potatoscript website
Category:Languages
Category:2021
Category:Total
Category:Implemented
Preface

Preface is a esolang by User:Yayimhere because of a discord discussion about No-code esolangs. 
== semantics ==
ignore program and take user input. the input will be the memory. the input is bounded to 256 chars but memory is unbounded. then if there is a (body) the the body will be appended to the end of the string again.
now we run this with these iterations:
* if the first char of the memory is a uppercase letter its lowercase version will be added to the end(with diacritic chaining and stuff)
* delete the first char of the memory
* append it back if it equal to the start of the memory if its not a letter
* halt unless the start of the memory is not {
* apply these substitutions in order(only of the start of the string and if a substitution is not applied then add move that symbol to end of memory):
 A->!
 2->!
 !;->!!;
 !!!!;->#
 #->##
 ###->!!!!!!!!!!!!!!!;#
 !!;#->!;#
 !;#->e(empty string)
* append memory to self unless end of memory is equal to the end
* repeat until halting
Category:Unknown computational class Category:Low-level Category:No-code esolang Category:Languages
Prefix notation

Prefix notation, or Polish notation, is one of the four operator notations. In this notation, an operator is written in front of all of its operands. It is sometimes combined with surround (when it needs a variable amount of arguments). It is one of the three powerful notations (Prefix, Postfix notation, Surround notation). 
== Examples ==
To write this line (presented in Infix notation),
 (2 + 2) * 4
In Lisp:
 (* (+ 2 2) 4)
Without varargs (pseudo-language):
 * + 2 2 4
In this pseudo-language varargs could be supported if parameters use lists for their parameters:
 *[+[2 2] 4]
which is closer to M-expressions than to the traditional S-expr Lisp structure.
== External Links ==
* Polish Notation on Wikipedia
Category:Concepts
Category:Operator_notations
Prefunge

Prefunge is a Befunge derivative by User:BoundedBeans.
==Syntax==
Prefunge is identical to Befunge, but now the C preprocessor is run on it. Additionally, the following restrictions are placed:
* Unless the first non-whitespace character on a line is #, the only allowed character set is AB(), along with whitespace.
* All defined macros must contain __TIME__. Obviously this means programs may run differently depending on when the program is preprocessed (which in this language is basically just compiling into Befunge).
* Depending on which interpreter is used after preprocessing, the macros __FUNGE_FBBI (FBBI), __FUNGE_C (cfunge), __FUNGE_RC (rcfunge), __FUNGE_SHARP (BefungeSharp), __FUNGE_PY (pyfunge), or whatever else will be defined. Prefunge implementations can either immediately call the interpreter, or, if it doesn't, it can depend on the user for determining that by passing in a command-line flag.
* Since a ton of extra lines are added by the C preprocessor apart from the actual preprocessed code, any line starting with # after the preprocessor has been run is removed.
==Variations==
There are a few flavors of Prefunge:
* Prefunge-93 (Befunge-93)
* Prunefunge-98 (Unefunge-98)
* Prbefunge-98 (Befunge-98)
* Prtrefunge-98 (Trefunge-98)
==Examples==
===Hello, world!===
#define AAAA __TIME__ $$$$$$$$"!dlrow ,olleH"zzzzzzz
#define AAAB @ __TIME__ $$$$$$$$ __TIME__ $$$$$$$$
#define AABA > __TIME__ $$$$$$$$ __TIME__ $$$$$$$$
#define AABB : __TIME__ $$$$$$$$ __TIME__ $$$$$$$$
#define ABAA v __TIME__ $$$$$$$$ __TIME__ $$$$$$$$
#define ABAB _ __TIME__ $$$$$$$$ __TIME__ $$$$$$$$
#define ABBA , $$$$$$$$ __TIME__ $$$$$$$$ __TIME__
#define ABBB ^ $$$$$$$$ __TIME__ $$$$$$$$ __TIME__
AAAA AABA AABB ABAA
AAAB ABBB ABBA ABAB AAAB
This expands to:
 "00:00:00" $$$$$$$$"!dlrow ,olleH"zzzzzzz > "00:00:00" $$$$$$$$ "00:00:00" $$$$$$$$ : "00:00:00" $$$$$$$$ "00:00:00" $$$$$$$$ v "00:00:00" $$$$$$$$ "00:00:00" $$$$$$$$
 @ "00:00:00" $$$$$$$$ "00:00:00" $$$$$$$$ ^ $$$$$$$$ "00:00:00" $$$$$$$$ "00:00:00" , $$$$$$$$ "00:00:00" $$$$$$$$ "00:00:00" _ "00:00:00" $$$$$$$$ "00:00:00" $$$$$$$$
and only runs in Prbefunge-98, because the lines are too wide for Prefunge-93 (Prefunge-93 is very limited due to the playfield limits and the wasted space from all the __TIME__ calls).
Category:Languages
Category:Turing complete
Category:2023
Category:Stack-based
Category:Unimplemented
Prelude

Prelude is an esoteric programming language created by Nikita Ayzikovsky in 2005. It uses several "voices", or "parts", each with its own stack, executing instructions in parallel. It is Turing-complete (it is trivial to compile Brainfuck into Prelude using just two voices).
Prelude is the ASCII representation of Fugue, which is the same language but using polyphonic music as source code.
==Basics==
A program is a set of instructions given for several "voices", one voice per line of text. Each voice has its own stack, initially containing an infinite supply of zeroes. Instructions given on the same column (i.e., for different voices but at the same time) are executed simultaneously. All stacks are updated atomically after the simultaneous instructions complete.
The actual type of numbers of the stack is left to the implementation, however it should allow negative numbers. The reference implementation uses signed integers of unlimited size.
==Instructions==
Command 	Description
Pop two values, add them, and push the result. 	
Pop two values, subtract the top one from the bottom one, and push the result.	
# 	Pop a value and discard it.
( 	If the top value on the stack is zero, skip past the matching ).
) 	If the top value on the stack is nonzero, skip back past the matching (.
^ 	Push the top value from the stack of the voice above this one.
v 	Push the top value from the stack of the voice below this one.
? 	Input a character and push it. EOF = 0.
! 	Pop a value and output it as a character.
0..9 	Pushes the appropriate one-digit number.
Anything else is treated as a nop.
( and ) do not have to be on the same line. It is an error to use both of them, or multiple instances of either, at the same time in different voices.
v used in the bottom voice pushes the value from the top voice; ^ used in the top voice pushes the value from the bottom voice. [citation needed]
==Formatting==
Instructions for the second voice are given below the first, and so on. A line of code can be broken by placing a line with just a single asterisk (*) after it.
==External resources==
* - Modified Feb 22, 2007, to address some ambiguities
* 
* Interpreter in C
* brainfuck to Prelude compiler
==See also==
* Fugue
Category:Turing complete
Category:Stack-based
Category:Languages
Category:Implemented
Category: 2005
Preparation

Preparation is an esolang invented by User:Hakerh400 in 2023.
== Syntax ==
Source code consists of a single natural number.
== Overview ==
Let z be the natural number from the source code. We define infinite sequence a_i such that a_0=z and a_{i+1}=k_i\left(k_i^2-a_i\right) for any natural number i, where k_i=\left\lceil\sqrt{a_i+1}\right\rceil. Notation \left\lceil x\right\rceil represents the ceiling function.
== Input/Output ==
There is no input. The output is the sequence a_i up to the first repeating number.
== Example ==
Let the source code be 1234. Here is the sequence a_i:
 1234
 2232
 3456
 1475
 1794
 2365
 1764
 3655
 4026
 4480
 603
 550
 624
 25
 66
 135
 108
 143
 12
 16
 45
 28 <--\
 48 |
 7 |
 6 |
 9 |
 28 ---/
Explanation. Start with 1234. Calculate k_0=\left\lceil\sqrt{1234+1}\right\rceil=36 and a_1=36\cdot(36^2-1234)=2232. Continue similarly for the rest of the sequence.
== Computational class ==
The author conjectures that this language is total.
== Implementation ==
Implementation
Category:Languages
Category:Implemented
Category:2023
Category:String-rewriting_paradigm
Category:Unknown computational class
Prepositional Calculus

Prepositional Calculus is a 4x4-matrix-based-but-somehow-also-stack-based esolang by User:Ϫ that is designed to break your brain.
==Commands==
There are only two commands, Ϫ and ϫ, but they form 8 different sets of 3.
Technically you can use any letter, using its upper and lowercase forms, but Ϫ is what I've used for this example.
* ϫϪϪ increases the X-value. (loops over)
* ϪϪϫ increases the Y-value. (loops over)
* ϫϪϫ pushes the current cell value to the stack and outputs the value of the current cell.
* ϪϪϪ resets the current cell.
* ϫϫϪ increases the value of the current cell by 1 and also pushes the user's input to the stack.
* Ϫϫϫ pops a value and adds it to the value of the current cell.
* ϫϫϫ skips the next program if the top value in the stack is 0.
* ϪϫϪ ends the program.
===Misc. Syntax===
If the program reaches the end without hitting a halt, it loops back around.
==Programs==
===CAT===
 ϫϫϪ
 ϪϪϪ
 Ϫϫϫ
 ϫϪϫ
 ϫϫϫ
 ϪϫϪ
 Ϫϫϫ
Category:Languages Category:2024 Category:Cell-based Category:Stack-based Category:Unimplemented Category:Unknown computational class
Preprocessor

This esolang is made by User:A, inspired by the C preprocessor.
==Syntax==
===Conditions===
The if-else directives if and end(End the if) can be used for conditional compilation.
 if VERBOSE >= 2
 /*Trace...*/
 end
The example code tests if the macro VERBOSE is greater than or equal to 2.
===Macros===
There are two types of macros, object-like and function-like. Object-like macros do not take parameters; function-like macros do (although the list of parameters may be empty). The generic syntax for declaring an identifier as a macro of each type is, respectively:
 <identifier>=<replacement token list> // object-like macro.
 <identifier>(<parameter list>)=<replacement token list> //Function-like macro.
Note that a function defenition can take more than 1 lines, as long as it ends with end.
There are, of course, operators(math,logic,comparison)which are not listed here.(They are exactly the same as in C)
Oh, just forgot to tell you how to call the function:
function()
To use a marco value:
macro
==Computational Class==
This is an attempt to compile Home Row into Preprocessor, using only 2(2 is enough, as said here) variable-macros.
Well, if that is wrong, you can define 8.
Define 2 variables:
 a=0
 b=0
a:
 a=a+1
Just note that a can be both a and b.
s:
 a=a-1
d and f
This does not produce direct code(Just switch the variables).
k and ;
This also doesn't produce any code, but(I think) this woultn't affect TC-ness.
j
Well, that is easy:
 if n!=0
 //1st command
 end
 //second command
l
more complicated...
 loop()=if a != 0
 //Stuff all your loop commands HERE
 loop()
 end
 if a == 0
 end
 end
Category:Languages
Category:Turing complete
Category:Turing tarpits
Preserve Line Numbers

Preserve Line Numbers is a twin language of Remove Line Numbers also created by User:None1, there is almost no difference, the only difference is that Remove Line Numbers removes all the line numbers but Preserve Line Numbers removes all the text.
==What it Can do==
Preserve Line Numbers is much less powerful than Remove Line Numbers, because Remove Line Numbers can print anything, but Preserve Line Numbers can only print a sequence of decimal integers starting from 1, separated by line feeds.
But preserve line numbers is also more powerful than Remove Line Numbers, because it has infinite number of quines, but Remove Line Numbers doesn't have any.
==Example Programs==
===Print 1===
 1 Blah Blah Blah, no matter what this is.
===An easier way to print 1/Quine===
 1 
===Print integers from 1 to 10/Quine===
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
==Interpreters==
===C++ as Windows executable (64bit)===
#include<cstdio>
#include<cstdlib>
char line[1000000];
int Gets(char *line){
	int i=0,flag=0;
	while(1){
		char c=getchar();
		if(c==EOF||c=='\n') line[i]=0;
		if(c==EOF) return EOF;
		if(c=='\n') return 0;
		if(c!=' ') flag=1;
		if(!flag) continue;
		line[i]=c;
		i++;
	}
}
void error(){
	puts("Invalid syntax");
	exit(1);
}
#define gets Gets
int main(){
	int l=0;
	while(1){
		l++;
		int x=-1;
		if(scanf("%d",&x)==EOF) break;
		if(x!=l) error();
		gets(line);
		printf("%d\n",l);
	}
	return 0;
}
==See Also==
* Remove Line Numbers
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:2023
Category:Implemented
Category:Total
PrettyPrint

PrettyPrint is an esoteric language where whitespace is sensitive and the whitespace used somehow figures into the types of expressions. It was invented for SIGBOVIK 2022.
== References ==
* Stefan Muller, “A Type-and-Affect System for Semisignificant Whitespace” (2022-04-08), pp. 16, proceedings of SIGBOVIK 2022, The Association of Computational Heresy, ISSN 2155-0166.
* Stefan Muller, “A Type-and-Affect System for Semisignificant Whitespace” (2022-04-08), video of presentation in SIGBOVIK 2022 conference
Category:Languages
Category:2022
Category:Implemented
PrimeFuck

PrimeFuck is a language inspired by Brainfuck. It is created by RacistCat. The language is designed to be very difficult and annoying to use.
=Instructions=
prime(x) means xth prime
Command	Pseudocode
p 	mem[data_ptr] = prime(mem[data_ptr] + 1)
d 	mem[data_ptr] //= 2
^ 	data_ptr = prime(data_ptr + 1)
v 	data_ptr //= 2
. 	print(chr(mem[data_ptr]))
, 	mem[data_ptr] = prime(get_char())
[ 	while mem[data_ptr] != 0 {
] 	}
=Programs=
There's program that prints "Hello, World!" and it is ~3KB. 
=Open Questions=
Is creating a "cat" program in this language possible? Is this language even Turing-Complete? 
=Interpreter=
https://github.com/RacistCat/PrimeFuck
Category:Usability unknown
Category:Languages
Category:Implemented
Category:Cell-based
Prime Notary

Prime Notary is an esolang by user Ϫ. It is based on the principle of prime notation.
==== A brief summary of prime notation ====
Prime notation is a system where any integer can be expressed by a series of prime terms, multiplied together:
 2a X 3b X 5c...
The prime number itself is known as a root, and the power is known (ironically) as the factor.
== Instructions ==
 Caption text
Header text	Header text
aN+ 	Increases the factor of the given root by 1.
a+ 	Increases the value of the variable by 1, and then recalculates the notation.
aN- 	Decreases the factor of the given root by 1.
a- 	Decreases the value of the variable by 1, and then recalculates the notation.
a! 	Sets jump point A
>a 	Goes to jump point A
ab?2 	Checks if the first variable given has a larger factor in the specified root than the second one. If it does, it executes the next line of code. If it doesn't, it skips it.
ab? 	Checks if the first variable given has a larger overall value than the second If it does, it executes the next line of code. If it doesn't, it skips it.
a> 	Outputs A as an integer
a>> 	Outputs A as an ASCII code.
! 	Halts the program.
=== Other important features ===
* The character $ can be used as a variable, but initially is set to the user's input.
* If an invalid instruction is shown, it simply halts, much like a Turing machine.
== Programs ==
===== Truth machine =====
 >a
 b!
 b>
 !
 a!
 $b?
 >b
 c!
 $>
 >c
===== Cat =====
 $>
 
sorry but i'm too lazy to work out prime notarization for the giant ascii values for hello world. can someone fix this?
Category: LanguagesCategory: Cell-based
Primordial

Primordial Is the temporary name for a hypothetical programming language inspired by real-world chemistry and particle interactions. It is currently being designed by highly intelligent people such as yourself.
==Brain-icanes==
Needs inspiration, ideas, and a name.
* Language based around chemistry, perhaps with synthetic elements, using reactions of various sorts to perform operations. Could be made somewhat like Fractran. --
*You could construct elements from some fundamental subatomic particles. 3 or 4 would be sufficient, but there's always room for more (or less) -Seven Inch Bread
**It would be self-modifying in the sense that these reactions form new elements with their own unique properties, which may also be in new reactions. -Seven Inch Bread
**The programmer could define elements and associate them with single characters. Those characters could then be placed in a textual 2D grid. With just the initial state set and the elements defined, the program would begin to react. Sounds like a functional/object-oriented cellular automaton. -Seven Inch Bread
*A standard library of ions and anions could be provided as an include. Ions could be treated as variables and assigned values, which might then be altered, concatenated, or split in reaction. Perhaps a programmer should be able to indicate the medium in which a given reaction is taking place; if solubility rules are specified in the library, you could consider precipitates to be standard output. -Evincar of Autumn
You'll need a bit more than 3 or 4 subatomic particles. If we ignore the heavier ones (they aren't essential), we have a minimum of these:
* Electrons and Positrons (four possible polarizations)
* Photons (four possible polarizations)
* Up and anti-up quarks (three possible colors)
* Down and anti-down quarks (three possible colors)
* Neutrinos and anti-neutrinos
* Gluons (eight possible color pairs)
* W-particles (positive, negative, and neutral)
You can also add heavier (later generation) subatomic particles:
* Muons and anti-muons (like electrons and positrons)
* Taus and anti-taus (like electrons and positrons)
* Mu-neutrinos, tau-neutrinos, and their opposites
* Charm and top quarks and their opposites (like up quarks)
* Strange and bottom quarks and their opposites (like down quarks)
You may also want to add gravitons, but they have not yet been proven, so their value is dubious. —Maharba 19:08, 10 July 2011 (UTC)
==Hypothetical examples==
A scratchpad for trying out semantic layouts. The exact syntax can be picked later. None of this is definite.
Let's say : is the define-element operator. The subatomic particles are * % and `. Comments begin with a #.
@ : *`**%**%`*%% #defines the "@" element with 
 # *`**%**%`*%% as its subatomic layout
& : *%%` #defines & with a *%%` subatomic layout
#<--Begin physical space->
 
 
 
 & @ & #a simple molecule. subatomic relations
 #would create bonds between the elements
 #giving them a (breakable) cohesion.
 
 @
 ^ #<-- sets @ into motion at start???
#<--end physical space->
-Seven Inch Bread-
Category:ideas
Print

Print is an esolang made by A designed to make Print Function Deluxe programs (slightly) shorter.
== Commands ==
If operators are provided less operands than what they need, spaces will be padded on the end.
Character	What it does
p 	Print and returns the next 3 characters. Prints numbers in base 10.
$ 	When before a function character, use a value from input as the argument for it.
% 	Set the accumulator to the next 3 characters as a base 255 number.
^ 	Similar to $, but use the accumulator instead.
= 	If the operand is even, go forward [the next character as a base 255 number] lines. Lines are counted from 0. Otherwise, proceed.
+ 	Increment the second operand by the next character as a base 255 number.
- 	+, but decrement the accumulator instead.
* 	Double the operand.
? 	Return a random number.
& 	Set the accumulator to the next character as a base 255 number.
@ 	Go to line [the next returned character as a base 255 number]; line numbers start from 0.
NL 	Newline, end the program
== Examples ==
=== Hello, World! ===
pHelplo,p Woprldp!
=== Cat program ===
$p
=== Truth-machine ===
=$&1p0
@p1
Category:Languages
Print("Hello, World!")

:Note that print("Hello, World!") is typically lowercased.
A print("Hello, World!") program prints the code for a Hello, World! program in the same language, for example, in Python, it would be print("print(\"Hello, World!\")"). You could take it a step further and do print("print(\"print(\\"Hello, World!\\")\")"), but that would be a print("print(\"Hello, World!\")") program. Note that this changes from programming language to programming language, so the JavaScript print("Hello, World!") program would have to print console.log('Hello, World!');, and brainfuck would have to print ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++..
Oh, yeah, I'm User:5anz, forgot to mention that. This is actually my first page that's neither an Esolang or my user page, so... idk how to do this.
== Implementations ==
Please add more languages here.
=== brainfuck ===
 ++++++++[>+++++>+++++++++++>++++++++<<<-]>+++........>+++.>--.<<....>.>.<<..>>.<<...>>.<<...>>.<<.>>--....<<++.>++.>++.<<--.>>.<<.>>.<<++.>>..<<--.>--.>--.<++.>.<<++.>.>++..<<+.>>.<<-...+.---.......+++..---...+++.>>..<<.>>--.<<-.+.>>.<<.---...+++.-......+.-........+.>>++..<<---.+++.>>.<<---..+++.
===Befunge===
 "@_,#:>"75*1-"Hello, World!"75*1->:#,_@
===G Sharp===
 make main;[print("make main;[print(\"Hello World\",\\n)]")]
===Python===
print("print(\"Hello, World!\")")
===Text===
 Hello, World!
==External resources==
Category:Program forms
Print "deadfish"

Print "deadfish" is a little extension of the Deadfish programming language.
It adds two new commands: The "h" commands which ends the program and the "p" command which prints the current value as an ascii character.
The interpreter is written in batch:
@echo off
setlocal enabledelayedexpansion
set b=☺☻♥♦♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂
:a
set/pi=^>^> 
if %i%==i set/aa=%a%+1
if %i%==d set/aa=%a%-1
if %i%==s set/aa=%a%*%a%
if %i%==o echo %a%
if %i%==p echo !b:~%a%,1!
if %i%==h goto :eof
if %a%==256 set a=0
if %a%==-1 set a=0
set i=n
goto a
Category:Languages