nyuuzyou/wikis huggingface dataset:
PingPong

PingPong is a 2D esoteric programming language similar to Befunge.
== Flow control ==
PingPong manipulates the program flow control using a variety of operators which treat the IP as a ping-pong ball, which reflects off each flow control instruction at a 90-degree angle.
Flow control instructions include:
 / reflect left-up and right-down
 \ reflect left-down and right-up
 | reflect left-right, ignore up-down
 _ reflect up-down, ignore left-right
 # skip next instruction
 = skip if top value on the stack is equal to zero
 > skips if top value on the stack is greater than zero
 < skips if top value on the stack is less than zero
Loops are written in a similar manner to Befunge - by creating literal 'loops' . This led to the eventual creation of Befreak, a reversible programming language that borrows this behavior.
PingPong has a varied set of instructions for performing arithmetic, stack manipulation, and a couple logical operations (AND and NOT). Additionally, PingPong is designed to support threading, function calls, and a set of API instructions for manipulating IO streams.
== Implementation ==
Pingpong uses several non-ascii characters, and has its own character code (0-255) that includes several PingPong-specific non-display characters.
== Hello World ==
This is merely one method of implementing the common Hello World program in Pingpong.
 1-dlroW$ olleH#/<\@
 \./
== External resources ==
* 
Category:Languages
Category:Stack-based
Category:Turing complete
Category:Two-dimensional languages
Category:Implemented
Category:Low-level
Category:Self-modifying
Category:Object-oriented paradigm
Category:2001
Pip

Pip is a golfing language made by Dlosc for writing answers on Code Golf Stack Exchange. Its syntax is generally C-like, with inspiration from JavaScript, Python, Perl, Lisp, and Rebmu. It uses plain ASCII.
Pip's main reason for existence is to be a golfing language that 1) is imperative, and 2) uses infix operators. I do enjoy the challenge of stack-based programming from time to time, but I find the imperative paradigm much easier to think in, and therefore better. In a survey of Code Golf StackExchange submissions, Pip scored slightly better than GolfScript and CJam, but not quite as good as Pyth.
Hence, Pip may not be highly competitive, but it is a very good golfing language to start off with and understand.
As of April 2024, Pip sits at 32nd place in the Code Golf and Coding Challenges Elo rankings, with a rating of 1501. 
== External Resources ==
* Official documentation
* GitHub repository
* Tutorial (unfinished)
=== Online interpreters ===
* Attempt This Online
* Do Stuff Online
* Try It Online (an older version of Pip called Pip Classic)
Category:Languages Category:2015 Category:Golfing language Category:Implemented Category:Turing complete
Pipefuck

Pipefuck or Pipef*** is an esoteric programming language created by User:WolfgangTS. It is a Two-dimensional version of Brainfuck, and therefore is turing complete.
== Concepts ==
=== The tape ===
Just like brainfuck, Pipefuck has a tape, and a pointer. There are no variables. So the tape serves that purpose. (In depth explanation)
=== The map ===
In pipefuck, every program is a map, or a maze, and the cursor navigates it. There are two directional operations
== Operations ==
In pipefuck, every character is an operation. When the cursor moves over it, it is executed.
Operation 	Result
- 	Same as Brainfuck, decreases tape[ptr]
+ 	Same as Brainfuck, increases tape[ptr]
> 	Same as Brainfuck, increases ptr
< 	Same as Brainfuck, decreases ptr
/ 	Will act as a direction modifier, just like a mirror would turn the light -90 degrees. e.g. if you are heading west, you will now be heading south.
\ 	Will act as a direction modifier, just like a mirror would turn the light 90 degrees. e.g. if you are heading west, you will now be heading north.
~ 	Skips next character, keeps going in the same direction.
* 	Skips next character if tape[ptr] == 0, keeps going in the same direction.
, 	Same as Brainfuck, sets tape[ptr] to the ASCII value of an input character
. 	Same as Brainfuck, stdout.writes the ASCII chaaracter at tape[ptr]
and = 	Acts as a path for the 'light', is required for the program to work. Note that they are interchangeable.
@ 	Will stop the program, regardless of position or direction.
any other character	This will 'teleport' to another equal character, if there are multiple, it will pick one randomly.
== Computational Class ==
Pipefuck is turing complete. You can translate any Brainfuck program to Pipefuck, thus making it turing complete. Here is the translation of a simple addition program in Brainfuck and then in pipefuck:
 ++++ 4 at t0
 >+++ 3 at t1 
 <[
 >+
 <-
 ]
 
The result will be a tape like so: [0, 7]. The same result is achievable in pipefuck this way:
 =++++\ 4 at t0
 /+++>/ 3 at t1
 <
 \~/>+=\
 @\*-</
== Comments ==
Comments are very easy to achieve, any code that is unreachable, will never be executed, so you can write to your hearts content. There is an issue however, if you are using 'portals', your program might start teleporting all over the place.
== Example programs ==
=== Cat program ===
 ,~$.,*$
Note, $ is used as a portal.
=== Multiplication program ===
\
\++++\
/++++/ EIGHT
>
\+++++\
/+++++/ TEN
<
| MULTIPLY
| IN [x], y
\=~/>~/>+>+<<-*\\
 | \========/>
/ \*-<</*->+<\~/
| \=====/
>
\~/-\
/>\*/
>
\~/<+=\ SHIFTL
/<\*->/
\~/<+=\ SHIFTL
/<\*->/ 
\~/<+=\ SHIFTL
/<\*->/ 
@
Will take [8, 10] and change it to [80, 0, 0]. Note the trailing 0 is a memory cell it used.
== Implementation ==
A quick and messy implementation without I/O by User:WolfgangTS: Gist here 
Category:LanguagesCategory:2016Category:Brainfuck_derivatives
Piping

== Piping ==
piping is a language that was made in a day. 
the basic consecpt is that you can pipe data to different places.
=== typing ===
there are several types
--tanks
--numbers
--strings
--code
=== commands ===
there is only one command, pipe.
there are several ways to use pipe:
 pipe (h) into (g) as (k)
 set a property (k) of the varible (g) with the value (h)
 pipe self into (g)
 add varible (g)
 pipe (g) through (k) with (f)
 use the filter (k) on the varible (g) with flags (f)
 pipe (g) through (k)
 use the filter (k) on the varible (g)
 pipe exit
 close the program
=== filters ===
diferent filters enact diferent things
 loop
 takes in two parameters:
 times,
 content
 runs the (content) (times) many times 
 output
 prints the input varible
 input
 when used,varible gets a new key added to it called input, that contains the user input.
 exists
 checks if a varible exists, it takes parameters:
 test [the varible to test[don't question it]],
 outcome
 it uses flags:
 -true runs (outcome) if (test) exists 
 -false runs (outcome) if (test) dosent exist
 run
 takes (outcome) as a parameters, then runs outcome
 eql
 takes the parameters:
 prm0
 prm1
 outcome
 if (prm0) equals (prm1) then run (outcome)
 it uses flags
 -true runs (outcome) if (prm) 
 -false runs (outcome) if not (prm)
 grt
 takes the parameters:
 prm0
 prm1
 outcome
 if (prm0) is greater than (prm1) then run (outcome)
 it uses flags
 -true runs (outcome) if (prm) 
 -false runs (outcome) if not (prm)
 lst
 takes the parameters:
 prm0
 prm1
 outcome
 if (prm0) is less than (prm1) then run (outcome)
 it uses flags
 -true runs (outcome) if (prm) 
 -false runs (outcome) if not (prm)
 add
 sub
 mul
 div
 mod
=== examples ===
hello * 32
 pipe self into g
 pipe 23 into g as times
 pipe {pipe 'Hello World!' through output} into g as content
 pipe (g) through loop
 pipe exit
truth machine
 pipe self into h
 pipe {
 pipe self into g
 pipe (g) through input
 pipe (g::input) into g as prm1
 pipe 1 into g as prm0
 pipe {
 pipe 0 through output
 pipe exit
 } into g as outcome
 pipe (g) through eql with -false
 } into h as outcome
 pipe (g) into h as test
 pipe (h) through exists with -false
 pipe 1 through output
=== external ===
interpereter(hard to use) https://editor.p5js.org/the.spiderminecart/sketches/G8Af8CdwA
Category:LanguagesCategory:Implemented
Pity

An attempt at a bigger, more tarry, turing tarpit, following similar "global rules" to Brainfuck (e.g., tape of byte-sized cells for instructions, moving "left" to "right") except with the tape for data being made of bits (see Boolfuck) accessed using a bit offset in byte-sized chunks. also, an extra variable, A.
instructions are as follows:
 &: [P] &= A
 !: [P] = ![P]
 <: P--
 >: P++
 x: swap([P], A)
P is an offset into the tape in bits, 
[P] is an 8-bit chunk starting from bit P of the tape,
A is a char.
This needs work, however, it seems to me that it could be turing complete were some kind of loop added, as combining & and ! and x can perform any logical bitwise operation, add in the ability to do bit-shifts via < and > and one can do addition and subtraction...
Category:Languages Category:Total Category:Cell-based
Pixiedust

Pixiedust is a Turing-complete assembly-like language created by Stephen Leppik with the intention of looking like pixie dust. First revealed in a 2018 Stack Overflow post, the language consists entirely of the symbols *+. plus whitespace. Whitespace has no effect on the program, but should be used liberally to achieve the desired aesthetic.
== Instructions ==
The full list of instructions can be found in the reference distribution.
== Hello World ==
A golfed Hello World program would look like this:
 ++.*+..+...
 ++.*++..+.+
 ++.*++.++..
 ++.*++.++..
 ++.*++.++++
 ++.*+.++..
 ++.*+.....
 ++.*+.+.+++
 ++.*++.++++
 ++.*+++..+.
 ++.*++.++..
 ++.*++..+..
 ++.*+....+
However, an equivalent but more Pixiedust-thematic Hello World program might look more like this: 
 + + . *+ .. +. .. . . . 
 .
 + + .* + +. . + .+ *
 ++. * + + . ++ . . * . . . . 
 .*
 + +. * + + .+ + . .* . . . . ..
 ++ . * ++. + ++ + * . . .. . .*
 + + .* + . + +. . . . . . . .
 + + .*+ . .. . .* . . . .. . . 
 .*
 + +. * +. + . ++ +*
 + +. *+ + . ++ ++ .. . ..
 + +. * + + + .. + .* .
 + + . * ++ . + + ..* . ..
 + + . * ++. .+.. . . . . ... ..
 + + . *+ .. . . +*. . . . . .*
== External Resources ==
* Reference Distribution
* TIO Interpreter
Category:Languages Category:Implemented Category:Low-level
Pixilartil

Pixiliartil is a 100x100 esoteric programming language created in 2023.
==Commands==
Remember to use the default color pallete.
 Black (color 1) - Terminate program
 Red (color 3) - Move pointer right
 Purple (color 5) - Move pointer left
 Blue (color 8) - Print out ASCII code associated with number in cell being pointed to.
 Dark Green (color 11) - Ask user for input and store it to cell in pointer.
 Yellow (color 15) - Skip to corresponding chartreuse (color 13) if cell has 0.
 Orange (color 17) - Increment cell on pointer by 1.
 Hot Orange (color 18) - Increment cell on pointer by 100.
 Gray (color 20) - Decrement cell on pointer by 1.
 Grayish blue (color 21) - Decrement cell on pointer by 10.
==Reading order==
You read pixels in Pixilartil like you do text in english. Left-to-right, Up-to-down.
==Hello World==
Hello World in Pixilartil by Cinnamony is here.
Pizza

Pizza is a joke programming language created by Nicholas Smith as a glitch to the BBC question about false programming language on 1 July 2018. It contains only one instruction. It was designed to be an April Fool on the GlobalGameDevelopersForum site.
==Syntax==
Syntax is one very simple: The instruction is "READ", which writes "H3110" to a text file named "0WTPWT.txt".
==Example==
This example writes "H3110" to a text file named "0WTPWT.txt".
 READ
==Implementation==
Written in Python 3.
 i = input("Enter Command: ")
 if i != 'READ':
 print("")
 else:
 the_file = open("0WTPWT.txt","w") 
 the_file.write("H3110")
 the_file.close()
==See also==
* Feta
 
Category:Joke languagesCategory:ImplementedCategory:2013Category:Output onlyCategory:Unusable for programmingCategory:Languages
Pizza Delivery

Pizza Delivery is yet another esolang by Cortex designed to be similar to the logic of other Cortex languages, but more concise. It is named after the Spider-Man 2 Pizza Theme (despite having no real relation), and it is ideal that you play the song on loop while coding in Pizza Delivery. Its data model is technically a 2-dimensional array of cells, but Cortex prefers to call it a square. It might be a finite-state automaton.
== Squares ==
The square is a 16x16 "grid" of numbers. Each "tile" in the square can have a value from 0 to 255. For the sake of brevity, this explanation will use a 4x4 square instead of the standard 16x16. At the start of the program, the square would look like this (an asterisk indicates the location of the pointer):
[*0,0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
When a tile is selected, you can read and write to the value of the tile.
== Commands ==
Character 	What it does
wasdqezc 	Move the pointer in the square north, west, south, east, northwest, northeast, southwest, or southeast
? 	Get a number from user input and write it to the selected tile.
` 	Print the value of the selected tile (which will from here on be referred to as L) as an ASCII value
+-* 	Increment, decrement, or double the selected tile
: 	
Next character	Value written to L
P 	Whether L is prime or not. (0 for false, 1 for true)
E 	Whether L is even.
R 	Pseudocode: charCode(rot13(String.fromCharCode(L)))
Example 	Example
Example 	Example
Example 	Example
== Examples ==
=== Hello, World! ===
21d64d72d57d20d2Cd6Fd6Cd65d48`a`a``a`a`a`a`ddd`aaaa`ddddd`aaaaaa`a`.
=== 1 character cat program ===
Input must be the character's ASCII value.
?`.
=== Truth-machine ===
?[31`]30`.
=== Primality test ===
?:P`.
== External resources ==
* Interpreter in Python 3
Category:Languages
Category:2019
Category:Cell-based
Category:Finite state automata
Category:Implemented
Category:Thematic
Placement

Placement is a programming language designed to be unusable to people who aren't at one of Earth's poles. The interpreter is connected to a GPS and accepts only three commands: !, ?, and :. : clears the program stored in memory, ? runs the program stored in memory, and ! appends a Brainfuck character to the program depending on the interpreter's longitude.
Character	Longitude
> 	Between 0º W and 45ºW
< 	Between 45ºW and 90ºW
+ 	Between 90ºW and 135ºW
- 	Between 135ºW and 180ºW
. 	Between 180ºW and 135ºE
, 	Between 135ºE and 90ºE
[ 	Between 90ºE and 45ºE
] 	Between 45ºE and 0ºE
Category:Joke languagesCategory:2014Category:Brainfuck equivalentsCategory:LanguagesCategory:Brainfuck derivativesCategory:Cell-based
Playlist

Playlist is an esoteric programming language based on playlists invented by User:A.
==Rules of operation==
Playlist operates over a playlist. There are a few commands in Playlist; they are listed here.
Sequential means to play the next item in a playlist.
Looping means to play the first item in a playlist.
Random means to choose a random next item in the playlist.
Unique is a condition to check whether all items are played.
Played is a condition to check whether the player is playing an item that was already played.
==Shorthand Notation==
S = Sequential
L = Looping
R = Random
U = Unique
P = Played
==Example programs==
===Plays all in playlist randomly without repeating===
Random Played
Random Played
Random Played
Random Played
Random Played
Random Played
Random Played
Random Played
The  specifier indicates a conditional jump; it only allows playlist switching when the right side 
of the expression is not true.
===An example of a looping algorithm. This evaluates 8! = 40320 times.===
Looping Unique
Looping Unique
Looping Unique
Looping Unique
Looping Unique
Looping Unique
Looping Unique
Looping Unique
===Finish the playlist===
Sequential
Sequential
Sequential
Sequential
Sequential
Sequential
Sequential
Sequential
==Interpreter==
* Common Lisp implementation of the Playlist programming language.
Category:Languages
Category:2019
Category:Implemented
Category:Low-level
Please Porige Hot

Please Porige Hot [sic] is an esoteric programming language by User:Zzo38 with a superficial resemblance to SON-OF-UNBABTIZED.
==Examples==
===99 bottles of beer===
 1 Please put beer in the porige
 2 1 2 3 4 5 6 7 8 9101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
 3 Please porige hot or in the pot nine days old + 1
 4 Please porige hot on the wall
 5 Please porige hot ,go North
 7 Please porige hot ,go South
 8 Please porige hot in the scoop
 9 Please porige hot ,go North
 10 Please porige hot in the pot
 11 Please porige hot ,go North
 13 Please porige hot in the pot
 14 Please porige hot ,go North
 16 Please porige hot in the pot
 18 Please porige hot ,go South
 318 Please porige hot ,go South
 319 Please porige hot in the scoop
 321 Please porige hot ,go North
 322 Please porige hot in the pot
 323 Please porige hot ,go North
 325 Please porige hot in the pot
 326 Please porige hot ,go North
 328 Please porige hot in the pot
 329 Please porige hot or in the pot nine days old x 0
 330 Please porige hot or in the pot nine days old + 2 .5
 331 Please porige hot on the stove
 332 Please porige hot out the window
 334 Please porige hot or cold bottles of beer
 335 Please porige hot or in the pot nine days old + 5
 337 Please porige hot in the pot
 338 Please porige hot out the window
 339 Please porige hot in the scoop
 340 Please porige hot ,go South
 341 Please porige hot out the window
 343 Please porige hot or cold bottles of beer on the wall,
 344 Please porige hot ,go South
 346 Please porige hot out the window
 347 Please porige hot or cold bottles of beer
 349 Please porige hot or cold Take 1 down and pass it around,
 350 Please porige hot in the pot
 351 Please porige hot or in the pot nine days old x 0
 352 Please porige hot or in the pot nine days old + -1
 353 Please porige hot on the flor 331
 355 Please porige hot in the scoop
 357 Please porige hot ,go South
 358 Please porige hot in the scoop
 359 Please porige hot in the pot
 361 Please porige hot ,go North
 657 Please porige hot in chapter 7
 659 Please porige hot or cold No more bottles of beer on the wall.
==External resources==
* Home page - contains specification and an implementation
* PleasePorigeHot entry on C2 Wiki
Category: Languages
Category:Implemented
Category: 2004
Plis

(note: this needs updating)Plis (programming language in scratch) is a language designed in scratch(3).
It has a fixed number of variables and lists.
It copy's much from assembly languages.
==examples==
hello world:<BR>
?"hello world".<BR>
truth-machine:<BR>
?;í=1;ï2;.<BR>
quine:<BR>
?ć.<BR>
add 2 numbers:<BR>
?;xï?;?+xï.
==List==
{| class="wikitable"
!name
!type
!sudo code
|-
|?
|write
|ask(read())
|-
|.
|write
|stop_all()
|-
|"
|read
|while code[i]!='"' and not ESC:return.append(code[i])
|-
|NOT_DEF
|read
|while code[i]!=';':return.append(code[i])
|-
|í
|write
|if if():pc=read()
|-
|ï
|read
|return answer
|-
|=
|if
|return read()==read()
|-
|ć (not implemented)
|read
|return code
|-
|+
|read
|return read()+read()
|-
|x
|write
|var x=read()
|-
|x
|read
|return x
Category:Languages
Pljic!

PLJIC! is a programming language created by User:Mmmph! as a thing to do.
== Overview ==
PLJIC! code is executed one character at a time, much like HQ9+.
== Commands ==
* P prints the internal variable.
* L label, sets the label position to it's position in the program.
* J jumps to the current label.
* I takes input from the user as a string, and stores it in the internal variable.
* C if the internal variable is "0", jump.
* ! ends the program.
== Examples ==
False machine:
ILPC!
Cat program:
LIPJ
== Implementations ==
There is an implementation in L1-OS but it's closed source for now.
A python implementation coming soon-ish :)
Category:2024
Category:Languages
Category:Implemented
Plts

plts (programming language that sucks) is a stack-based programming language.
==Commands==
* ?[letter]: push letter to the end of the stack
* %[letter]: push letter to the beginning of the stack
* &: prints last item of stack
* $: prints first item of stack
* #: prints stack
* @: prints stack but reversed
* <: removes first item of stack
* >: removes last item of stack
==Installation==
# Download Python 3.9
# Download the 'main.py' file from the github repository
# Run python3 [main.py file path] [(optional)code file path]
==Hello world! program==
 ?H?e?l?l?o? ?w?o?r?l?d?!#
Category:Languages Category:2020 Category:Implemented Category:Total Category:Unusable for programming Category:Output only
Plugh

Plugh is a stack based language which is missing one of the key features of stack based languages: a push operation. Working around this is somewhat annoying to do.
==Syntax==
The language has 10 commands. The first eight are represented by octal digits and the last two are "xyzzy" and "plugh". The digits can be concatenated without any whitespace, but the words must have spaces on each end. All sequences of these are valid Plugh programs.
==Operation==
A program starts at the top of an infinite stack initialized with the natural numbers (that is to say, the top value on the stack is 0, followed by 1, then 2, et cetera.)
Each command is then executed in sequence. The actions performed by each command follow.
The 0 command duplicates the top value on the stack.
The 1 command deletes the top stack value, removing it forever.
The 2 and 3 commands do something different. They move the top of the "active" stack. When this has been moved below some elements, those elements effectively don't exist until it's moved back up. For example, imagine the stack S 1 2 3 4, where S is the stack pointer. When 2 is run, it looks like: 1 S 2 3 4. If 1 is then run, it looks like this: 1 S 2 2 3 4. If 3 is then run, it looks like this: S 1 2 2 3 4. Note: these commands always move up or down by the top value on the stack, stopping when they reach the top.
The 4 command copies an element from the top of the "active" stack to the top of the actual stack (which can also be changed; see commands 6 and 7.) For example, the stack looks like 1 S 2 3 4. If 4 is run, it looks like 2 1 S 2 3 4.
5 does the opposite, copying from the top of the actual stack to the active stack.
Category:Languages Category:Stack-based Category:2019 Category:Unimplemented
Plus

Plus is an esolang created by User:None1 and inspired by PlusOrMinus and Lenguage and b̶r̶a̶i̶n̶fuck. It has an accumulator that can contain unsigned integer of any size (initially 0).
==Tokens==
There are 2 tokens: + and EOF. The + command increases the accumulator. EOF converts the accumlator into a big endian base-256 number and outputs every digits in the resulting number as ASCII (if the number is 0 then do nothing).
==Plus+==
Plus+ is a minimized version of Plus that uses the number of pluses instead of the real pluses
==Examples==
===Nope. interpreter===
====In Plus====
336877085998 (0x4e6f70652e) +'s.
====In Plus+====
 336877085998
===Hello World===
====In Plus====
22405534230753928650781647905 +'s.
====In Plus+====
 22405534230753928650781647905
===XKCD Random Number===
====In Plus====
 ++++++++++++++++++++++++++++++++++++++++++++++++++++
When the number of + is less than 256, a Plus program behaves the same when executed in b̶r̶a̶i̶n̶fuck.
====In Plus+====
 52
==Interpreter==
===Python===
====Plus====
a=input().count('+')
s=[]
while a:
 s.append(a%256)
 a=a//256
while s:
 print(chr(s.pop()),end=)
====Plus+====
a=int(input())
s=[]
while a:
 s.append(a%256)
 a=a//256
while s:
 print(chr(s.pop()),end=)
Category:Languages
Category:Joke languages
Category:Total
Category:Unusable for programming
Category:Output only
Category:2023
Category:Implemented