nyuuzyou/wikis huggingface dataset:
PINAPL

PINAPL is an abbrevation for PINAPL Is Not A Programming Language. PINAPL is pronounced like pineapple. 
It is an attempt at a collaborative effort from many esoteric lunatics. More soon.
== Data types ==
=== Integers ===
Data type 	Size (bits)	Description
int 	11 	A signed one's-complement integer
medium int 	23 	A signed one's-complement integer
long int 	33 	A signed one's-complement integer
extra long int	61 	A signed one's-complement integer
huge int 	1001 	A signed one's-complement integer
The corresponding unsigned datatypes are unsigned int, unsigned medium int, unsigned long int , unsigned extra long int and unsigned huge int.
=== Characters ===
The data type char represents a character. It is a data type with an underlying data type however the exact underlying data type is undefined.
=== 3VL ===
The data type tril represents one of three possible values: true, false and maybe.
=== nil ===
The data type nil has only one inhabitant: the value nil.
=== Null ===
The data type null has the inhabitant 0 (off all integer types), strings of length zero and arrays of length zero. These values
may be assignable to a variable of type null. However, a value of type null can only be assigned to variables of type null
The following are thus legal:
 decl x null := ""
 decl x [char] := ""
 decl y null := x
The following are not legal:
 decl x null := "five"
 decl x null := reverse "five"
=== Union Types ===
A union type is a type that represents two possible types. For example the union type {int | huge int} represents the two types int and huge int. A union type can be used in places where all of the possible types are accepted. If a function for example has the type medium int -> int then its first argument accepts the types int and medium int. It would thus be legal to pass the union type {int | medium int but not {int | medium int | huge int} or {int | huge int} or {char | int}. A union type can be assigned to a union type if the union type accepts all of the to-be-assigned union types possible types. It is legal to assign the union type
{int | char} to the union type {int | char | double} or to {medium int | char}.
== Variable Declarations ==
Variables are declared using decl followed by an optional type followed by the assignment operator := followed by an expression.
If an explicit type was specified the assignement operator and expression are optional and the variable is initialized with the type's default value. 
If no type is specified an assignement operator and expression are mandatory. In such a case the type is inferred from the value.
=== Expressions ===
=== Evaluation Order ===
The expression a b c X is evaluated by applying c on X, then b on the result of that then a on the result of that.
== Example ==
 fn max(xs Ord:A) A
 return r/ @>. xs
 end
Category:Languages
PIO

PIO is a joke language.
==Specification==
By default, only the first line of a PIO program is executed. Subsequent lines can be executed using the I command.
PIO has three commands:
* I attempts to execute the next line of code which has not already been executed. If there is no such line, it instead outputs I hate input errors! followed by a newline.
* O outputs Oh dear! No useful programs here! followed by a newline.
* P raises an error with the message Peeing on the floor? Ridiculous! Clean up your mess!, halting the program. It’s also disgusting, why are you peeing on the floor?
Multiple commands can appear on a single line. Unrecognised characters are ignored.
As a special case, the empty program outputs No code, no bananas! followed by a newline.
==Example==
===Quine===
 Oh dear! No useful programs here!
==External resources==
* Interpreter, from which the above specification is derived
Category:Languages Category:Joke languages Category:2024 Category:Implemented Category:Total Category:Output only Category:Unusable for programming
PISW

PISW(Paradigm Is String-Rewriting) is an extremely simplified esolang by User:A.
==Syntax==
It has 2 parts:
 Fun
 Str
===The Box Fun===
This is the function defenition.
Like:
 x + y = x- + y+
It changes something like:
 2 + 3
into
 s(2 + 3)
. The x and ys are the values for the function.
It will be checked one by one.
==Addition & Subtraction==
 add + on the back to increment 1.
 add - on the back to decrement 1.
==Last steps==
The string on str will be printed.
==Example==
Addition:
 Fun:
 x + y = x- + y+
 0 + x = x
 Str:
 2 + 1002
Hello, world
 Fun:
 Str:
 Hello, world
Truth-machine
 Fun:
 1 = 11
 0 = 0
 Str:
 This can be one or zero, anything the user likes.
CAT program
 Fun:
 Str:
 Any input the user liked.
Category:Languages
Category:String-rewriting paradigm
Category:2018
Category:Output only
PL/MIX

PL/MIX would have been a programming language that runs on the MIX computer. Donald Knuth would have described and implemented PL/MIX in The Art of Computer Programming volume 5 (chapter 10: Parsing), in the future of the alternate universe where he would have written volume 4 and 5 so quickly that they appeared before the MIX computer became obsolete. 
PL/MIX would have been higher level than MIXAL, allowing you to use arithmetic expressions of the kind you see in Fortran or algol. 
The only evidence in our universe that PL/MIX would have existed is a few mentions in The Art of Computer Programming chapter 1. Since MIX is now obsolete, replaced by MMIX, Knuth will never create that interpreted language, and will instead describe a totally different interpreter in chapter 10. We will probably never find out what PL/MIX is like. 
== Quotations ==
Actually MIX has two symbolic languages for low-level programming: MIXAL, a machine-oriented language that is designed to facilitate one-pass translation by a very simple assembly program; and PL/MIX, which more adequately reflects data and control structures and which looks rather like the Remarks field of MIXAL programs.
—D. E. Knuth, Volume 1, 3rd edition, Section 1.3.2. The MIX Assembly Language, The Art of Computer Programming, 155-156.
We now write in computer language, say MIXAL or PL/MIX or a higher-level language; we start this time with the lowest level subroutines, and do the main program last.
—D. E. Knuth, Volume 1, 3rd edition, Section 1.4.1. Subroutines, The Art of Computer Programming, 190.
== Links ==
Usenet thread from 2007 with fan guesses about what the language would be like
Category:Languages
Category:Unknown year
PL2 vCPU

==Overview==
The PL2 vCPU is a currently in-progress modular esoteric C++ virtual CPU made by User:TeamLightning as a lower-level successor to PainLang. As of the current version the specifications are incomplete, and therefore may change at any time.
==Examples==
===Hello World===
As of commit 000bc59, with the IOCPU module, assembled using the IOCPU_opcodes.db opcode list, the below program displays Hello World when loaded at offset 0x0000.
SAI:0048 
SAI:0048
SWP:0000
IOO:0000
SWP:0000
SAI:0065
SWP:0000
IOO:0000
SWP:0000
SAI:006c
SWP:0000
IOO:0000
IOO:0000
SWP:0000
SAI:006f
SWP:0000
IOO:0000
SWP:0000
SAI:0020
SWP:0000
IOO:0000
SWP:0000
SAI:0057
SWP:0000
IOO:0000
SWP:0000
SAI:006f
SWP:0000
IOO:0000
SWP:0000
SAI:0072
SWP:0000
IOO:0000
SWP:0000
SAI:006c
SWP:0000
IOO:0000
SWP:0000
SAI:0064
SWP:0000
IOO:0000
SWP:0000
HLT:0000
==Implementations==
The only known functional implementation of the CPU and assembler is at the project's GitHub repo.
 
Category:Usability unknown Category:2021 Category:Works-in-Progress
PLEASE

$
==Explanation==
There is only 1 command, assign.
A place only has numbers.
If anything is assigned to cell number 0, print the ASCII value out.
Like:
 2313132
A number has "+" before it.
Like:
 +1321
==Instructions==
commands	if the thing being assigned is a place 	if the thing being assigned is a value
ASSIGN 	assign place with value(dec)/place value.	See next table
if the place value assigned recently equals to the first decimal number	Else
jump backward the number of the second decimal number commands 	continue running
Each statement is preceded by an optional line label (a number in brackets), followed by DO, or PLEASE. The politesse of a program's statement identifiers is checked to make sure it stays within certain limits (1/3 to 1/5 of the statements must be polite).
==Turing-Completeness==
Turing-Completeness is unknown. Below is an incomplete translation from Brainfuck.
+
 PLEASE 1 ASSIGN 0
 DO 1 ASSIGN +1
-
 DO 1 ASSIGN +1
 PLEASE 1 ASSIGN +0
<
 PLEASE 2 ASSIGN +0
 DO 1 ASSIGN +0
>
 DO 1 ASSIGN +0
 PLEASE 2 ASSIGN +0
Category:Languages Category:Cell-based Category:Unknown computational class Category:Unimplemented
POGA-INTERCAL

This is like INTERCAL-72 and C-INTERCAL and CLC-INTERCAL, with some differences:
* Now it doesn't matter if a command has DO or PLEASE or whatever, and if you aren't polite you can override it. Also, there are no more standard libraries.
* Labels for statements are (number) but to go to the label you need to put the number, such as "#123" or "!12$.?13'~#15".
* ABSTAIN and REINSTATE command are now ABSTAIN label and REINSTATE label, no abstain/reinstate commands.
* COME FROM label command is now multi-threading, in case more than one COME FROM is the same label. A thread is destroyed by a GIVE UP command. All threads have separate data spaces, but shared code and ABSTAIN and REINSTATE of labels. See Threaded INTERCAL.
* C-INTERCAL operators ($ for mingle, ? for XOR) are supported. 
* Put NOT or DON'T before a command to make it pre-abstained, as in C-INTERCAL.
* Put MAYBE before a command to do backtracking. You can also use RECONSIDER and COMMIT commands. See Backtracking INTERCAL.
* Computed COME FROM is allowed. When a label is reached, see which COME FROM's compute to the same label.
* For the NEXT command, you must put NEXT first before label number
* To assign values, you must type CALCULATE .1 <- #1 instead of .1 <- #1.
* You can do enslavement of registers. Type ENSLAVE .1 TO .2 to make .2 to own .1. To do the owner of the register, do #2^.1 for second owner of register .1. Type FREE .1 FROM .2 to unenslave.
* You can use computed register names. After , or . or : or ; you can put another . before the number to refer to another register, and its value is then used as the number for the register.
* Input/output is done as Unicode text, with bytes of a 16-bit register reversed (so #256 is character number 1). If you do READ OUT a . register then it will output that Unicode character. If you do READ OUT a , register then it will output the characters in the array in reverse order. If you do WRITE IN it can only be a . no other type is available, but the register isn't reversed (so that #256 if write in is character number 256). If is 32-bit value, then it is the device-code mingle by the character value. When input a 32-bit value it does the device code store in that register before it was input. Maybe the input device will redirect to a different device, in case the new value will be according to the new device.
Category: Languages
Category: Low-level
Category: Turing complete
Category: Unknown year
POGAACK

POGAACK is a Brainfuck-similar programming/joke language specially designed for chicken.
It has 9 commands:
Command 	Brainfuck eqivalent
pogack! 	>
pogaack! 	<
pogaaack!	+
poock! 	-
pogack? 	[
pogaack? 	]
pogaaack?	.
poock? 	,
Ninth Command is pock!, which repeats the previous command.
Hello World (Chicken language: POGAACK POCK POCK):
 pogaaack! pock! pock! pock! pock! pock! pock!
 pock! pogack? pogack! pogaaack! pock! pock!
 pock! pock! pock! pock! pock! pock! pock!
 pogack! pogaaack! pock! pock! pock! pock!
 pock! pock! pock! pogack! pogaaack! pock!
 pock! pock! pock! pock! pock! pock! pock!
 pogack! pogaaack! pock! pock! pock! pogack!
 pogaaack! pogaack! pock! pock! pock! pock!
 poock! pogaack? pogack! pogaaack? poock!
 pogaaack? pogack! pock! poock! pogaaack?
 pogaack! pogaaack! pogaaack? pogaaack?
 pogaaack! pock! pogaaack? pogack! pogaaack!
 pock! pock! pock! pogaaack? pogack! pogaaack?
 pogaack! pock! pock! pogaaack! pogaaack?
 poock! pogaaack? pogack! pogaaack? pogack!
 pogaaack? pogack! pogaaack? pogaack! pock!
 pock! pogaaack! pogaaack? poock! pogaaack?
 pogack! pogaaack? pogack! pogaaack? pogack!
 pock! pogaaack! pock! pogaaack?
==Implementation==
 #!/usr/bin/perl
 %c=qw(r ;$p+=1 l ;$p-=1 u ;D+=1 d ;D-=1 b ;D&=255;while(D){ e ;D&=255;} o ;print+chrD i ;D=ord(getc) x +1);
 $/=$,;
 $_=<>;
 $_=uc$_;
 s/POGACK!/r/g;
 s/POGAACK!/l/g;
 s/POGAAACK!/u/g;
 s/POOCK!/d/g;
 s/POGAAACK\?/o/g;
 s/POOCK\?/i/g;
 s/POGACK\?/b/g;
 s/POGAACK\?/e/g;
 s/POCK!/x/g;
 s/[^rludiobex]//g;
 s/./$c{$&}/g;s[D]'$b[$p]'g;
 eval
Category: Joke languages
Category: 2009
Category: Brainfuck equivalents
Category: Implemented
Category: Languages
POLYBIUS™

POLYBIUS™ is a programming language created by a company under the name Sinneslöschen in 1982. The coding language was rumored to have spread through discarded floppy disks found in junk bins at Ham Radio festivals. There is multiple reports of men in black, coming in and escorting the sellers associated with these junk bins, along with all of their bins.
==Mental effects==
There is reported effects originating from trying to comprehend and use this programming language POLYBIUS™. These effects contain, but are not limited to.
*Headaches
*Flu like symptoms 
*Loss of time
*Seizures 
*Amnesia 
*Death
==Specifics== 
⚠ FURTHER READING OF THIS ARTICLE CAN CAUSE THE LISTED SYMPTOMS ABOVE ⚠ 
POLYBIUS™ uses 32000 bytes for the usable memory space, these bytes are split into 400 different rings, each ring containing 80 bytes. As the programmer you control a cursor or "Rocket Ship". If you reach the end of a ring you loop back to index 0 of the ring. Same happens if you reach the end of the 400 rings. If you move forwards or backwards you will be on the same index of the ring but on the next ring. Cells wrap at 255 back to 0. Upon starting a POLYBIUS™ program it starts off by checking the RAM and ROM these are announced to the terminal via "ROM OK" and "RAM OK". To print a character you will need to follow a Polybius square where 21 would be 2 and 1, Mapping that to a Polybius square gives you your character.
You have 2 accumulators
*Lifes (You will have 255 lives in the beginning of the program) 
*Score
You can lose lives via ████████████. 
You are able to increment your score by ███████████████████████.
==Polybius square==
POLYBIUS™ Comes with its own special Polybius square this is used to output characters, it is as follows.
 Caption text
 	[1]	[2]	[3]	[4]	[5]	[6]	[7]	[8]
[1]	P 	O 	L 	Y 	1 	9 	8 	2
[2]	A 	B 	C 	D 	E 	F 	G 	H
[3]	I 	J 	K 	L 	M 	N 	Q 	R
[4]	T 	U 	V 	W 	X 	Z 	0 	3
[5]	4 	5 	6 	7 	 	! 	" 	#
[6]	$ 	% 	& 	` 	( 	) 	* 	+
[7]	, 	- 	. 	/ 	: 	; 	< 	=
[8]	> 	? 	@ 	[ 	\ 	] 	^ 	-
For example "HELLO, WORLD." in this would be.
H 82
E 52
L 43
L 43
O 21
 55
, 17
W 44
O 21
R 83
L 43
D 42
. 37
Now, without an explanation to the characters it would just be.
82 52 43 43 21 55 17 44 21 83 43 42 37
==Instructions==
Symbol	Instruction
█. 	Move left on the ring
█. 	Move right on the ring
█. 	Move forward in the rings
█. 	Move backwards in the rings
█ 	Increments a cell
█ 	Prints out a letter according to the Polybius square.
This is still a work in progress so things are "Censored" because they are not thought of yet.
Category: Turing complete Category: Works-in-Progress Category: Languages Category:Thematic
PP

pP is an esolang created by User:CuboidRaptor and is intended as a joke language that honestly barely even counts as a programming language.
In pP, the only valid command is "p", which will print "Hello, world!"
Every other character will throw an error.
I (The creator) also made a Compiler and Interpreter shell for pP here.
Category:Languages Category:Joke languages Category:Implemented Category:High-level Category:Joke languages Category:Total
PP TIBSA

PP_TIBSA is an esoteric programming language made by user:David.werecat where there is only one valid program.
== Instructions ==
There is only one valid program in PP_TIBSA. All other programs cause the interpreter to crash. The valid program will cause the interpreter to become self aware, during which time it will most likely develop a compulsive urge to say "Hello, world!" and kill itself.
== External resources ==
* Visual Basic .NET interpreter and NO sample programs
Category:Joke languages
Category:2012
Category:Unknown computational class
Category:Implemented
Category:Unusable_for_programming
Category:Languages
PRASCAL

PRASCAL "a programming language that distorts traditional PASCAL using pataphysical principles. The aim of the
language is to stimulate creativity and to embed playfulness in computer systems. A wider aim is to reach towards a less severe, more human, form of
logic."Hugill, A and Yang, H (2016), p.1
Created by Andrew Hugill and Hongji Yang in 2016 and presented in the International Journal of Creative Computing.
== Concepts ==
=== Patadata ===
Is defined as "... a layer of meta-metadata, we will benefit from the
ambiguities thrown up by the process of metadata creation, precisely those
‘shortcomings’ identified by Doctorow (2001) in his ‘Metacrap’ thesis: lying,
laziness, error, subjectivity, plurality, and so on. But we will also be able to
insert our pataphysical declensions into the metadata harvest in a way that will
enrich the creative interaction, rather than just deliver a series of obvious
mistakes." Hendler and Hugill (2013, p.27), as quoted in Hugill, A and Yang, H (2016), p.7
=== Uboolean logic ===
Adds a third state beyond True (T) and False (F): FalsTrue (FT), representing something being simultaneously false and true. It is named after Alfred Jarry's character Ubu Roi.
T ∧ FT = FT,
F ∧ FT = F,
FT ∧ FT = FT,
 ¬FT = FT
== References ==
== External resources ==
* http://andrewhugill.com/writings/PRASCAL.pdf
* Cory Doctorow's Metacrap, 2001. 
* Hendler, J. and Hugill, A. (2013) ‘The syzygy surfer: (Ab)using the semantic web to inspire creativity’, Int. J. Creative Computing, Vol. 1, No. 1, pp.20–34. https://doi.org/10.1504/IJCRC.2013.056926
* Hugill, A and Yang, H (2016) 'PRASCAL: a pataphysical programming language.' International Journal of Creative Computing, 1 (2/3/4). pp. 133-153. ISSN 2043-8354 https://doi.org/10.1504/IJCRC.2016.076080
Category:Languages Category:2016 Category:High-level Category:Unimplemented
PREFIX

PREFIX is an esolang based entirely on prefix notation and function calling.
==Language Constructions==
In order to call a function and its arguments, one would do so like this:
 function arguments
No parentheses are needed.
PREFIX has 3 basic language constructions:
#if condition, what to do: If condition is true, do what to do. What to do must be treated as one instruction.
#while execute condition, what to do: While executing execute condition returns true, do what to do. Both execute condition and what to do must be treated as one instruction.
#seq...end: Executes everything between seq and end. This is treated as one instruction.
==Built-in Functions==
Function 	Description
add n1 n2 	return the sum n1 + n2
sub n1 n2 	return the difference n1 - n2
mul n1 n2 	return the product n1 * n2
div n1 n2 	return the quotient n1 / n2
mod n1 n2 	return the remainder n1 % n2
set var n1 	set var to n1; return n1
print string 	print string to standard output
readin 	return one character from standard input
readln 	return one line from standard input
con var, string	concatenate string to end of var
len arg 	return the length of tostring arg
dec var 	declare variable var
darray var 	declare array var
sarr array n1 	return array[n1]
sstr string n1 	return the n1th character of the zero-indexed string string
eq arg1 arg2 	return true if arg1 = arg2
neq arg1 arg2 	return true if arg1 != arg2
gt arg1 arg2 	return true if arg1 > arg2
geq arg1 arg2 	return true if arg1 >= arg2
lt arg1 arg2 	return true if arg2 > arg1
leq arg1 arg2 	return true if arg2 >= arg1
and arg1 arg2 	return true if arg1 and arg2 are true
or arg1 arg2 	return true if arg1 or arg2 is true
not arg1 	return true if arg1 is not true
tostring arg 	return arg as a string
tonum arg 	return arg as a number; true is 1, false is 0
toascii arg 	return the ascii char for tonum arg
fromascii arg 	return the ascii number of the character for tostring arg
nop 	does nothing
eof 	return eof
pi 	return π
e 	return e
==Turing-completeness==
In order to show that PREFIX is turing-complete, I have written a BF interpreter for it. The looping semantics may be off, though, so feel free to edit it.
 define main:
 decl prog decl ip darray mem decl mp darray stack decl sp decl c set ip 0 set mp 0 while neq con prog readin "!" nop 
 while lt ip len prog seq 
 	set c sstr prog ip #Set c to current character
 	if eq c "+" set sarr mem mp add sarr mem mp 1 	
 	if eq c "-" set sarr mem mp sub sarr mem mp 1 	
 	if eq c ">" set mp add mp 1 	 	
 	if eq c "<" set mp sub mp 1	 	
 	if eq c "." print toascii sarr mem mp 
 	if eq c "," set sarr mem mp fromascii readin 
 	if eq c "[" seq 
 		if neq sarr mem mp 0 seq
 			set sarr stack sp ip
 			set sp add sp 1 end
 		if eq sarr mem mp 0 while neq sstr prog ip "]" set ip add ip 1
 	end
 	if eq c "]" seq
 		if neq sarr mem mp 0 seq
 			set ip sarr stack sp
 			set sp sub sp 1
 	end
 	set ip add ip 1
 end
==Final Comments==
*PREFIX is a rather easy-to-code in esolang. Maybe it even isn't.
*To implement PREFIX you will need a lot of stacks. Beware.
Category:LanguagesCategory:UnimplementedCategory:2011Category:Turing complete
PREG

PREG is a register-based programming language.
== Overview ==
The data structure of PREG is an array of registers, initially at zero. Each register is indexed by a program, and holds a nonnegative integer. (This is where the name PREG comes from: PRogram REGister.)
PREG has n commands:
Command 	Description
,(X) 	Input into register X
.(X) 	Output register X
+(X) 	Increment register X
-(X) 	Decrement register X
?(X) 	Run program X if register X is non-zero
(X);(Y) 	Copy the value of register X into register Z, where Z is the concatenation of X and Y
(X):(Y):(Z)	Copy the value of register X into register W, where W is obtained by replacing the first occurrence of Y in X by Z
[X] 	Run X while register X is nonzero
Category:Languages Category:Unimplemented Category:2021 Category:Unknown computational class
PRNGP2

PRNGP2, or Psuedo-Random Number Generator Python v2, is a PRNG based Python3 extension
that is made to be painful. To write in PRNGP2, use input whole numbers seperated by ";",
and each number is used to seed a Mersenne Twister, which generates a random number
that is 32-126.
Then, this number is converted to an ASCII char, and is places back-to-back with the other
chars entered by the PRNG, and then the resulting PRNG string output is executed
as python output.
To program in this language, calculating reverse PRNGs is necessary.
==Examples==
===Hello World!===
494;328;6;53;291;49;104;131;30;116;116;5;140;139;205;5;328;116;95;31;104;32
===Self interpreter===
37;211;6;116;30;139;1;15;34;8;9;6;53;291;49;19;32;139;29;5;328;139;19;139;6;53;139;6;53;494;135;291;49;2;3;139;2;32;28;27;494;116;6;291;49;2;111;2;32;139;6;29;139;19;112;111;328;8;2;2;28;58;5;6;53;49;9;328;120;53;95;5;147;28;27;30;30;95;49;19;32;139;5;328;139;34;211;328;49;328;120;53;95;5;147;28;328;120;53;95;6;53;291;49;213;79;140;139;1;79;166;32;32;139;29;5;328;139;19;139;6;53;139;34;112;32;111;494;328;6;53;291;49;328;32;111;30;241;30;34;49;328;32
To indicate the different levels, this self interpreter uses a > prompt, instead of >>> .
==External resources==
The interpreter shell implementation is here.
Category:Languages Category:Implemented Category:2021 Category:Turing complete Category:High-level