nyuuzyou/wikis huggingface dataset:
PAC

PAC is an esoteric programming language, created by User:CMinusMinus, consisting of "point and click adventure" commands.
Command 	Action
OPEN -VAR- 	Create variable
USE -VAL- WITH -VAR-	Var = Val
TALK "Hello World" 	Prints "Hello World"
Talk -VAR- 	Prints ascii value of variable
Talk #-VAR- 	Prints variable
PUSH -VAR- 	Var = Var + 1
PULL -VAR- 	Var = var - 1
GIVE -VAR- 	Gets User input and saves it in "Var"
*-NAME- 	Set location for goto
WALK TO -NAME- 	Goto location -name-
TURN OFF -A- -B- 	Break out of goto if "A" > "B"
----
==Important==
===Comments===
Comments are initiated with a semicolon (;).
They cannot be placed into code.
===Variables===
Variables have to be initialized.
They are always integers.
==Example Programs==
===Hello World===
 TALK "Hello, World!"
===Cat===
 OPEN x
 GIVE x
 TALK x
===Range 500===
At a certain range, the interpreter throws a RecursionError.
 OPEN max
 OPEN c
 USE 500 WITH max
 *start
 TALK #c
 PUSH c
 WALK TO start
==Links==
* Github
* Online interpreter using TIO. Code goes in the code section, so make sure to leave the header and footer alone. - Based on the github repo
PANOPTES's Dumb Burger Thing

Here is the story of how PANOPTES's Dumb Burger Thing, or DumbBurger for short, was created.
Right around now, I was procrastinating.
I still am.
And while I was procrastinating, this code for generating the first 10 elements of the Fibonacci Sequence came into my head.
Hello, I'd like two Number 1s and a Large Number 10. //Pushes 1 twice and a Coke onto the stack. Pushes a 10 onto the large stack.
I have a friend who would like a Coke to go, and a Large Fries. //Loop declaration.
//The coke evaluates to the sum of the top two elements of the stack. As the coke is to go, its value is outputted.
//The fries evaluate to the top element of the stack minus 1.
//Eventually, the top element of the large stack should equal zero, meaning the loop is exited and the program halts.
Here are the operators I came up with so far:
A Number N evaluates to N.
Coke evaluates to the sum of the top two elements of the stack.
Diet Coke evaluates to the top element of the stack plus 1
Onion Rings evaluate to the topmost element of the stack minus the second topmost.
Fries evaluate to the top element of the stack minus 1.
A Chicken Sandwich evaluates to the topmost element of the non-Large stack.
Most of the boring syntractic stuff can be figured out from the above example, but here's some more:
Every line after the first is prefaced with "I'd also like" unless it's part of a loop.
This is how you declare a multilne loop, as well as nested loops.
I'm also ordering for a friend.
They'd like...
They'd also like...
They're also ordering for a friend.
Their friend'd like...
Their friend'd like...
Okay, moving on.
Okay, moving on.
Y'all are welcome to add more ideas.
Category:Unimplemented Category:Stack-based Category:Languages Category:Pseudonatural
PAPEL

PAPEL (Particle Automata Programming Ephemeral Language) is a stack-based esoteric programming language created by User: LolloDev5123 intended to be stored on 
paper using hole punches of different shapes. 
== Instructions ==
Instruction 	Hole-punch Symbol
Do nothing 	⛆⛆⛆
Do nothing 	🞆
Set top stack value to 0 	🞊
Swap top and second stack value 	🞲
Rotate top 3 stack values clock-wise 	◔
Rotate top 3 stack values counter-clock-wise 	◕
Push NumArg to Stack 	▶
Push random number (from min in stack to max in stack) to stack 	🟊
Increment top stack value 	▲
Decrement top stack value 	▼
Push sum of first and second stack value (pop first 2 & push sum) 	🞧
Push difference of first from second stack value (pop first 2 & push difference)	⚊
Push product of first and second stack value (pop first 2 & push product) 	🞬
Push quotient of first from second stack value (pop first 2 & push quotient) 	◢
Square top stack value 	◼
Repeats all functions after itself, until a 🞚 is reached 	🞛
Repetition halt 	🞚
Mod-3 top stack value 	⛬
Breakpoint 	◻
Square root top stack value 	⚑
Push input from user (ascii value/integer) to top of the stack 	☷
Output top of the stack (as ASCII Char) 	☰
Output & pop from top of the stack 	☲
== NumArgs ==
For instructions that require arguments (▶), in the right section of the paper, there is a space intended for 8-bit binary numbers. (○/●)
== File/Instruction Set Format ==
The format starts with the "¶ Program Name" and then separates into 2 columns,
the left column is padded by 2 spaces and holds the operator or instruction while the
right column holds the number argument, which is expressed as an 8-bit binary integer by default "○○○○○○○○".
The right column is only evaluated or used when the instruction requires a value neither from output nor from the stack (▶).
It can also be used to mark the line number whenever it isn't needed for the "▶" instruction.
Anything written outside the "Paper" or ASCII Box is considered a comment:
 ╔═════════════════╗
 ║ ¶ Program Name ║
 ║ 🞆 ║ ○○○○○○○○ ║
 ║ 🞆 ║ ○○○○○○○○ ║
 ║ 🞆 ║ ○○○○○○○○ ║
 ║ 🞆 ║ ○○○○○○○○ ║
 ║ 🞆 ║ ○○○○○○○○ ║
 ║ 🞆 ║ ○○○○○○○○ ║
 ╚══════╩══════════╝
 ( Op ) ( NumArg )
Category:Languages Category:Stack-based Category:Thematic
PAPER

PAPER is by Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff (talk) 23:53, 2 December 2024 (UTC)
It is a peice of paper that says "4".
It only has one state: XKCD
==Syntax==
==Examples==
===XKCD Random Number===
The FitnessGram Pacer test is a multistage aerobic capacity test that progressively gets more difficult as it continues. The 20 meter Pacer test will begin in 30 seconds. Line up at the start. The running speed starts slowly, but gets faster each minute after you hear this signal *boop*. A single lap should be completed each time you hear this sound *ding*. Remember to run in a straight line, and run as long as possible. The second time you fail to complete a lap before the sound, your test is over. The test will begin on the word start. On your mark, get ready, start.
===Quine===
 4
===Anti-Machine language iterating self interpreter ===
 +++[->++++<]>+[->++++<]>.
===Palindrome===
 e+++|->++++<|>+|->++++<|>.>|<++++>-|+>|<++++>-|+++e
===Print the meaning of life's tens digit===
 print( 42[ 10 ] )
===Self interpreter===
>>>>>+[->>++>+>+++++++[<++++>>++<-]++>>+>+>+++++[>++>++++++<<-]+>>>,<++[[>[->>
]<[>>]<<-]<[<]<+>>[>]>[<+>-[[<+>-]>]<[[[-]<]++<-[<+++++++++>[<->-]>>]>>]]<<]>[
-]+<<[--[[-]>>->+<<<]>>[-<<<<[>+<-]>>>>>>+<]<<]>>[-]<<>>>[<<<+>>>-]<<<]>>>+<<<
<[<<]>>[[<+>>+<-]+<-[-[-[-[-[-[-[->->>[>>]>>[>>]<+<[<<]<<[<<]<]>[->>[>>]>>[>>]
<,<[<<]<<[<<]]<]>[->>[>>]>>[>>]<-<[<<]<<[<<]]<]>[->>[>>]>>[>>]<.<[<<]<<[<<]]<]
>[->>[>>]>>[>>]<<-<<[<<]<<[<<]]<]>[->>[>>]>>[>>]+[<<]<<[<<]]<]>[->>[>>]>>[>>]<
[>+>>+<<<-]>[<+>-]>>[<<+>>[-]]+<<[>>-<<-]>>[<<+>>>>+<<-]>>[<<+>>-]<<[>>+<<-]+>
>[<<->>-]<<<<[-<<[<<]<<[<<]<<<<<++>>]>>[-<<<<<<[<<]<<[<<]<]>]<]>[->>[>>]>>[>>]
<[>+>>+<<<-]>[[<+>-]>>[-]+<<]>>[<<+>>>>+<<-]>>[<<+>>-]<<[>>+<<-]+>>[<<->>-]<<<
<[-<<[<<]<<[<<]<<<<<+>>]>>[-<<<<<<[<<]<<[<<]<]>]>[<+>-]<<<<<<[>>+<<-[->>->>+[>
>>[-<+>>+<]+<-[-[[-]>[-]<]>[-<<<+>>>]<]>[-<<<->>>]>[-<+>]<<<<[>>+<<-]>>]<<<<<<
]>>[-<<+[>>>[-<+>>+<]+<-[-[[-]>[-]<]>[-<<<->>>]<]>[-<<<+>>>]>[-<+>]<<<<[<<+>>-
]<<]]]>>>>>>>]
Category:Unusable for programming Category:Output only Category:Implemented Category:Languages Category:Joke languages Category:2024 Category:Total Category:Zero-dimensional
PATH

PATH, invented by Francis Rogers in August 2003, is a two-dimensional language inspired by Brainfuck and Befunge. PATH's environment, like Brainfuck's, consists of an array of memory cells all initialized to zero and character-based standard input and output. PATH understands the following commands:
Command	Explanation
$ 	Start the program here, heading right.
# 	End the program.
+ 	Increment the current memory cell.
- 	Decrement the current memory cell.
} 	Move to the next memory cell.
{ 	Move to the previous memory cell.
, 	Input an ASCII character from standard input into the current memory cell.
. 	Output an ASCII character from the current memory cell into standard output.
/ 	
If heading in direction:
:right, turn up
:down, turn left
:left, turn down
:up, turn right
\ 	
If heading in direction:
:right, turn down
:down, turn right
:left, turn up
:up, turn left
^ 	If the value of the current memory cell is not 0, turn up.
< 	If the value of the current memory cell is not 0, turn left.
> 	If the value of the current memory cell is not 0, turn right.
v 	If the value of the current memory cell is not 0, turn down.
! 	Jump over the next symbol.
As in Brainfuck, any character not understood as a command is simply skipped over.
==Computational class==
We can show how to convert any Brainfuck program into an equivalent PATH program, and in this way, show that PATH is in the same computational class as Brainfuck (i.e. that it is Turing-complete).
Consider the following trivial Brainfuck program:
 +[>-<-]
+ and - remain unchanged. < and > become { and } respectively. Finally, each [] loop can be coded idiomatically, using !/\v commands. This is spaced out for clarity in the following example:
 / v \
 + /!\ }-{- v!\
 \ /
==Variations==
Some implementations have added ] and [ to unconditionally direct the flow of the program right or left, but the PATH author has requested these implementors give their variants different names.
Languages based on PATH include SNUSP, which is more orthogonal and optionally supports advanced features, and LNUSP, which uses only 5 commands and supports diagonal control flow.
==External resources==
* Official PATH site with interpreter
* A javascript implementation of the interpreter
Category: Languages
Category: Implemented
Category: Turing complete
Category: Cell-based
Category: Two-dimensional languages
Category: 2003
Category: Turing tarpits
Category: Low-level
PAX16 CPU

The PAX16 computer, is a computer that runs using the PAX processor, made by Areallycoolusername. The PAX processor uses an esolang called Romanesco as its native machine code. Esoteric computer in this page, is defined as a computer that uses unconventional methods of computation, using an Esoteric processor, and an Esoteric Operating System.
== Specifics ==
PAX16 uses a feature of Romanesco called "Fracturing" to perform computations. The language itself is an OISC that only has one instruction, jump. The computer uses an OS, called HopliteOS, which is a lightweight, fast, operating system. The PAX16 computer, with its OS and machine language, Romanesco, is currently still in development. Further documentation may be found in the computers Github repo.
Category: 2019
PERPLEX

PERPLEX is an esolang created by Jussef Swissen (A pseudonym.) in 2014. It's basically a over-complicated version of BASIC. For example, PRINT is now INSCRIBE. Here's a list of the complicated commands.
BASIC 	PERPLEX
PRINT 	INSCRIBE
NEXT 	CONSEQUENT
INPUT 	DATA-PROMPT
IF 	ON-THE-OCCASION-THAT
ELSE 	CONTRAST
GOTO 	ADVANCETO
string ($)	lex (-L-)
LOCATE 	ESTABLISH
COLOR 	PIGMENTATION
number(%) 	CONSTANT(-C-) (As in algebra.)
equal(=) 	ASSIGN(-@-)
FOR 	CONSIDERING
TO 	PROCEED
STEP 	TREAD
REM 	DISREGARD
THEN 	THEREUPON
ELSEIF 	CONTRAST-ON-THE-OCCASION-THAT
WHILE 	WHILST
UNTIL 	PRIOR-TO
DO 	PERFORM
LOOP 	REITERATE
CLS 	ERASE PREVIOUS CODE (EPC)
END 	CONCLUDE
Here is a hello, world program in PERPLEX.
10 EPC
20 INSCRIBE "Hello, world!"
30 CONCLUDE
This language can do everything Commodore 64 BASIC can. A 99 bottles of beer program is being worked on.
Category:Languages Category:2014
PEWWWWW

Note: This is a work in progress. Some things may not be fully finished. You can find the original spec here.
PEWWWWW is an esolang created by User:Emerald. This specification was written by User:Monochromeninja. The language uses a single stack that only contains integers.
==Instructions==
An instruction of PEWWWWW is written like so:
 /== (statement>
 |condition
===Statements===
Statements can be one of the following:
* load n
Pushes n to the stack.
* shoot
Prints the top of stack.
* search n
Moves the n'th item from the top of the stack to the top. (1-based)
* reload n
Jump to the n'th instruction from the top of the program. (1-based)
* add
Pops a then b, then pushes a+b.
* sub
Pops a then b, then pushes a-b.
* mul
Pops a then b, then pushes a*b.
* div
Pops a then b, then pushes a//b. (Floor division -- divide and round down)
* mod
Pops a then b, then pushes a%b.
Statements can be separated using )s.
===Conditions===
Conditions can use the following operators:
 == (equal to)
 >> (greater than)
 << (less than)
 >= (greater or equal to)
 <= (less or equal to)
 ! (logical NOT)
===Literals===
Valid literals are:
* Integers (themselves)
* tru (Boolean TRUE)
* fal (Boolean FALSE)
* Strings (use double-quotes)
:* Escape character: \
:* Newline: \p
* top (Top of stack)
* get (Returns a single ASCII code from STDIN)
* toint s (Returns s converted to an integer)
* tostr i (Returns i converted to a string)
===Compressed mode===
This allows you to write smaller (albeit less readable) programs. Simply separate your statements with ;s and use this instead of the standard ASCII art gun:
 condition/==statement
These can be interspersed with noncompressed statements as well.
==="Extras"===
These are extra stacks that can be used as variables. Declare them using the following syntax:
 extra var
 |value|
 |value|
 <etc.>
To evaluate a statement inside a stack value, simply surround it with angle brackets like so: |<get>|.
Loading an extra will 
===Other notes===
 % marks a single line comment
 All errors have the same message: "No ammo".
PHAWN

PHAWN is a grid-based esoteric language. It uses a pointer to the current instruction, which bounces between the edges of the grid. Certain instructions will have the opposite meaning if executed when the instruction pointer is moving in a different direction. PHAWN is still on the drawing board.
==Language Overview==
PHAWN uses a stack to hold its data. The program begins at the entry point and the instruction pointer moves right by default. There is no instruction to change the direction of the pointer, it only changes when the end of the line is reached. The instruction at the end of a line is not executed twice. When the pointer comes accross an integer the register is set to that value. For integers which are longer than 1 digit (and therefore conflict with the consistency grid) the pointer considers the digit on the far left to be the position on the grid.
 $ Entry Point
 # Exit Point
 > Push the value in the register (Pop if moving right)
 < Pop the value on the top of the stack and places the value on the register (Push if moving left)
 } Input (Output if moving left)
 { Output (Input if moving left)
 / Skip (If the pointer is moving right)
 \ Skip (If the pointer is moving left)
 ^ Jump up to the next line
 _ Drop to the line below
 ~ Jumps if the top number is greater than the second top, otherwise it drops. (The stack is unchanged.)
 + Pop the top two values, add them and push the result
 - Pop the top two values, subtract the first from the second and push the result
 * Pop the top two values, multiply them and push the result
 ? Pop the top two values, divide the second by the first and push the result. A divide by zero is an error and no numbers are pushed but the top two values still popped.
 & Toggles output between Character and Integer. (Integer by default)
 % Pops the top two numbers and pushes them in reverse order. (Swaps the top two values)
 , Comment
 . Do nothing
==Examples==
The following a simple program in PHAWN which takes user input and immediately prints it out.
 #$}.
Here is the famous "Hello World" program.
 _ <
 _ $33>100>_ 114^
 _<72<101<<108>^
 _. /^/<111>\87\>\32\>
 &{{{{{{{{{{{{#
 , Output: Hello World!
Characters are pushed in the ASCII decimal form and printed out as characters.
This example prints Fibonacci numbers until they are greater than 100000000
 $1>2><>+>%_
 <<>>{^ _
 ~<100000000
 <{#
==External resources==
Python PHAWN Interpreter
Quine Written by Keymaker
Category:Languages
Category:Stack-based
Category:Two-dimensional languages
PHL 1.0

Proceed High Language 1.0 (also known as PROCEED) is a mildly esoteric programming language created by User:Fergusq in 2012.
== Syntax ==
There are three syntactical elements: procedure declaration, procedure or function call and a string constant. Everything that is not a declaration or a call is a constant. PHL 1.0 is based on substitution: a declaration is replaced with the name of the procedure and a call is replaced with the return value.
A basic declaration looks like this:
 procedure[ call1; call2; call3; ... calln ]
A procedure can contain an infinite number of calls. No spaces are allowed between The name of the procedure and [.
An anonymous function is like a basic declaration but without name.
A call is very similar to a declaration, except that [ and ] are replaced by ( and ).
 procedure( arg1, arg2, arg3, ... argn )
Again, no spaces should occur between the name and the (.
Example:
 printsum[
 println(The sum of A and B:);
 println(add(get(A), get(B)))
 ]
== Built-in functions ==
Function 	Description
if(;s;f;f) 	Calls the first procedure if the condition evaluates to true, otherwise the second. Condition is in format (val1)(op)(val2) where (val1) and (val2) are values and (op) is either ==, !=, <, >, <= or >=. Example: if(get(A)==get(B), [println(A is B!)], [println(A is not B)])
get(;s) = ;o 	Gets a variable.
set(;s;o) 	Sets a variable.
add(;i;i) = ;i 	Addition
sub(;i;i) = ;i 	Subtraction
mul(;i;i) = ;i 	Multiplication
div(;i;i) = ;i 	Division
mod(;i;i) = ;i 	Modulo
strCat(;s;s) = ;s	Concatenation
print(;s) 	Prints a string.
println(;s) 	Prints a line.
read() = ;s 	Reads a character.
readln() = ;s 	Reads a line.
Commands included in the Javascript interpreter:
Function 	Description
alert(;s) 	Creates a popup dialog.
prompt(;s) = ;s	Creates an input dialog.
== Examples ==
=== Hello World ===
 main[
 println(Hello World!)
 ]
=== Fibonacci sequence ===
 main[
 set(A, 0);
 set(B, 1);
 set(C, 0);
 set(I, 0);
 loop[
 if(get(I)<10, [
 set(C, add(get(A), get(B)));
 set(A, get(B));
 set(B, get(C));
 set(I, add(get(I), 1));
 println(get(I): get(C));
 loop();
 ], []);
 ]();
 ]
=== Truth-machine ===
Uses prompt() as the input function ~ change to read() if using command line input.
 main[
 if(prompt()==0, [
 println(0)
 ], [
 loop[
 println(1);
 loop();
 ]()
 ])
 ]
=== Stack ===
As the main data structure of PHL 1.0 is a hash map, can it be used to simulate a stack (or a queue or everything else).
 initStack[
 set(stack, 0)
 ]
 push[
 set(stack, add(get(stack), 1));
 set(strCat(stack_, get(stack)), get(value))
 ]
 pop[
 set(value, get(strCat(stack_, get(stack))));
 set(stack, sub(get(stack), 1));
 ]
Example usage:
 main[
 initStack();
 set(value, 1); push();
 set(value, 2); push();
 set(value, 3); push();
 pop(); println(get(value));
 pop(); println(get(value));
 pop(); println(get(value));
 ]
== Computational class ==
PHL 1.0 is believed to be Turing complete, but this has not been proved yet.
== External resources ==
* 
Category:LanguagesCategory:ImplementedCategory:Unknown computational classCategory:2012
PIGS

PIGS is a minimalistic esoteric programming language that is based around pointers, made by User:Yousurname. Its name originates from the four main commands in it: P, I, G, and S.
== Language overview ==
In PIGS, data is stored in variables that can be referenced through pointers. Variables are numbers that can be from 0 to 4294967295 (unsigned 32-bit). Each of the commands, except for #, is pointer-based. Each command takes a parameter in binary (0s and 1s) that directly follows the command symbol.
Command descriptions are taken from the GitHub repository.
 Commands
Command	Description
P 	Prints the corresponding character of the variable that the parameter points to. If this is impossible, then it prints nothing.
I 	Takes input starting with the variable that the parameter points to. The corresponding number of each character is stored.
G 	Starts running from a specific index (0-indexed) of the commands, specified by the variable that the parameter points to. If the index goes past the end of the code, then the program is terminated.
S 	Prepares to set the variable that the variable that the parameter points to, points to. By default this is 0.
+ 	Adds the variable that the parameter points to to the prepared variable.
- 	Subtracts the variable that the parameter points to from the prepared variable.
= 	Sets the prepared variable to 1 if it is equal to the variable that the parameter points to, otherwise 0.
: 	Sets the prepared variable to the variable that the variable that the parameter points to, points to.
# 	Sets the variable to the parameter.
The P and I commands use Unicode. All characters besides those described above are treated as comments. Because of how the language is designed and how it filters out anything that is not recognized as a command with a parameter, it is impossible to run into errors.
== Examples ==
Examples are taken from the GitHub repository.
* Hello, world!: #1001000P0#1100101P0#1101100P0P0#1101111P0#101100P0#100000P0#1110111P0#1101111P0#1110010P0#1101100P0#1100100P0#100001P0
* Truth-machine: #1S0#10S1#11110S0#11S1#11100S0#100S1#110001S0#101S1#10S0#110I1S0#111S1#0+110=100+101:111P110G111
* Infinite loop: G0
* Cat program: #1S0#10S1#1000S0#101S1#11110S0+0S1#100101S0+0S1#10010I10S0#11S1:10=100+0+0+0+0+0:11G11:10P11S0#10S1+0G111
* Scream very loudly: #1000001P0G1
== Computational class ==
Although there have been no proofs on PIGS's computational class yet, it is largely believed to be Turing complete as long as number values are unbounded because it can handle conditional branching and has the ability to change an arbitrary amount of memory.
It is thought to be that only the characters GS:1, + or -, and = or # are needed for Turing-completeness.
== External resources ==
* GitHub repository
* Online interpreter
Category:Implemented
Category:2022
Category:Turing complete