nyuuzyou/wikis huggingface dataset:
PointerTape

PointerTape is a tape-based programming language created by User:Asymptote. It is, as yet, incomplete. 
PointerTape is quite simple. A PT program consists of a "tape" (array) of symbols. 
Symbol	Function
> 	Moves the pointer to the right.
< 	Moves the pointer to the left.
H 	Halts the program.
wxy 	Writes the symbol x (either < or >) in the direction of y (also either < or >).
wxn 	Writes the symbol x (< or >) at position n.
jn 	Makes the pointer jump to position n.
As noted above, there is a great deal of functionality yet to be implemented in PT. A list of possible upcoming symbols follows:
Symbol	Function
x 	Stores the object x (which can be any Python-compatible variable)
sxp 	Creates a storage symbol at position p, and stores the value x there.
px 	Prints the symbol in the direction x (x is < or >).
pn 	prints the sybmol at position n.
E 	Causes the program to exit.
As soon as the needed functionality is implemented, the standard "Hello, world!" application will be posted. It should be something like this:
[p13,p14,p15,p16,p17,p18,p19,p20,p21,p22,p23,p24,p25,"H","e","l","l","o",","," ","w","o","r","l","d","!"]
Category:Languages
Category:Unimplemented
Category:2007
Category:Cell-based
Category:Works-in-Progress
Pointers

Pointers is a programming language that uses pointers to do stuff
= The Stuff To Know =
== Statements ==
These are the commands/instructions/statements.
 Statements
Instructions	Description
V = VAL 	Set V to VAL
V* = V 	Point V* to V
VAL 	Print VAL, note: it prints as a character if is a printable character, else a number
^V* 	Return the pointed value from V*
^V* = VAL 	Point the pointed value from V* to VAL
&VAL 	Goto line VAL
#COM 	Comments COM out
Note: V or VAL can be the Things: 3, 4, a var, a number/string, or a pointer
== Examples ==
These are the Examples.
=== Binary ===
 0* = 1*
 1* = 0*
 ^1* #0*
 ^0* #1*
Pointfree programming

Pointfree programming (or point-free programming or tacit programming) is a style of programming where you don't use bindings (names) for local variables or function arguments, and instead manipulate values in other ways, such as by composing builtin functions.
Pointfree programming is mandatory in several programming languages:
* Certain stack-based concatenative languages, such as Underload or Joy (programming language), where values are stored on a stack and can be rearranged on the stack by stack rearrangement builtins
* Functional languages based on Combinatory logic, such as Unlambda or SKI calculus or BCKW calculus (the latter two mentioned in Combinatory logic), where functions are curried, and builtin functions allow you to compose multi-argument functions.
* Functional languages such as Amicus and also Amycus, where functions take a tuple (they aren't curried), and primitives to compose multi-argument functions. John Backus's FP (programming language) is an early conceptual (used on paper only, not in computer) non-esoteric programming language that was built on this archetype and uses tuples. A further development of Backus FP is FP trivia (even with instance variables that correspond to the pointfree style). 
APL (derivatives Jelly, J, and K) is said to belong to this category.
Pointfree programming style is also sometimes used in some other languages that have named variables, so this isn't the only possible style. Such languages include PostScript (which has named mutable global variables and mutable arrays so you can write programs in a style used in early BASIC or FORTRAN), and Haskell (programming language) (which has lambdas and let expressions so you can write programs somewhat similar to those in lambda calculus or lisp, although Haskell is strongly typed so there are differences).
Category:Programming techniques Category:Concepts
Pointless.

Pointless is a point-free variation on 01_.
A Pointless program is a Pointless expression, which is a function that takes a list of bits and returns a list of bits.
==Syntax==
 program = expr, "." ;
 
 expr = compose | let | if | function ;
 
 compose = expr, expr ;
 
 let = "LET", identifier, "=", expr, { ",", identifier, "=", expr }, "IN", expr ;
 
 if = "(", expr, ",", expr, ",", expr, ")" ;
 
 concat = "(", expr, ",", expr, ")" ;
 
 function = identifier ;
Identifiers are consecutive sequences of non-whitespace characters, excluding (, ), ,, =, and .. Also, LET and IN are reserved and may not be used as identifiers. Whitespace separates identifiers and is otherwise ignored.
Comments begin with == and extend to the end of the line.
==Expressions==
===Compose===
 f g
This is a function that returns the result of applying f to the result of applying g to its argument.
===Let===
 LET f = (_,0,1) IN f.
A LET expression binds one or more identifiers, which may be referred to in the body of the expression or in the bodies of the bindings. Bindings in a LET may shadow bindings in any enclosing scope, including the initial scope. This function is the body of the LET expression, f in the above example.
===If===
 (f,g,h)
If the argument of this is an empty list, it returns the result of applying f to its argument.
If the head of the argument is 0, it returns the result of applying g to the tail of its argument.
If the head of the argument is 1, it returns the result of applying h to the tail of its argument.
===Concat===
 (f,g)
This is a function that returns the concatenation of the result of applying f to its argument and the result of applying g to its argument.
===Function===
A function may be an identifier bound in an enclosing LET expression or bound in the initial scope. The initial scope consists of
* _ ignores its argument and returns an empty list
* 0 returns its argument with 0 prepended
* 1 returns its argument with 1 prepended
==Examples==
===Hello world===
 0 0 0 1 0 0 1 0 1 0 1 0 0 1 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 0
 1 1 1 1 0 1 1 0 0 0 0 0 0 1 0 0 1 1 1 0 1 1 1 0 1 1 1 1 0 1 1 0
 0 1 0 0 1 1 1 0 0 0 1 1 0 1 1 0 0 0 1 0 0 1 1 0 1 0 0 0 0 1 0 0
 0 1 0 1 0 0 0 0 _.
===Cat===
 (_,0,1).
==References==
* Implementation
Category:Languages
Category:Implemented
Category:Turing_complete
Category:2020
Pointy

Pointy is a language by Ihope127. The basic datatype is the pointer.
== Instructions ==
The instructions:
 LBL foo: not really an instruction, but marks a destination for a DEC jump.
 CPY x y: stores the value x in memory location y.
 INC x: increments the value at memory location x.
 DEC x foo: tries to decrement the value at memory location x. If x already held 0, jumps to foo.
 OUT x: outputs x.
 INP x: inputs a value into the memory location x.
Pointers can be dereferenced using the * operator: *x is the value at location x. Since there is a memory location 0 (there is no null pointer), * never fails to produce a result.
== Examples ==
Hello, World!
 CPY 108 1
 CPY 111 2 
 OUT 72
 OUT 101
 OUT *1
 OUT *1
 OUT *2
 OUT 44
 OUT 32
 OUT 119
 OUT *2
 OUT 114
 OUT *1
 OUT 100
 OUT 33
Cat program
 LBL start
 INP 0
 OUT *0
 DEC 1 start ; the value at 1 will be 0, so this jumps to start
== Computational class ==
Pointy is Turing-complete because it can simulate a Minsky machine. It can also emulate Brainfuck with a tape that extends infinitely only to the right, as shown in the table below.
Let x store the current cell number, y be an unused value set to 0, and z be free for use.
Brainfuck operation(s)	Pointy operation(s)
 > 	
 INC x
 < 	
 DEC x
 + 	
 INC *x
 - 	
 DEC *x foo
 DEC y bar
 LBL foo
 CPY 255 *x
 LBL bar
 , 	
 INP *x
 . 	
 CPY *x z
 OUT *z
 [ 	
 DEC x foo
 LBL bar
 INC x
 ] 	
 DEC x foo
 DEC y bar
 LBL foo
== External resources ==
*Interpreter
*99 bottles of beer
Category:Languages
Category:2006
Category:Turing tarpits
Category:Implemented
Category:Low-level
Poison

The Poison Programming Language
Version 1.1
==Download Link==
Download Link: Click Here (Moved File to Dropbox So that it Remains for the Long Future ahead)
==Hello World Example==
p("Hello World!")
==A Little bit about the Poison Programming Language==
One day I was Bored and Decided to learn how to program in python so I went and watched some youtube videos however I didn't just want to program in Python I wanted to form my own language perhaps an easier No wait more simplistic version of Python with smaller command names And easier programming so here it is The Poison Programming Language
==Help==
p("String") - Allows you to print something to the screen
e("Name of batch file") - Allows executing of Batch files
n() - Shows a Note
c() - Shows copyright information
nm() - Shows language details
hlp() - Shows all the available commands
hlp_cmd("Command name") - Get help on a specific command
clear() - Clear the command line screen on a Linux Computer
cls() - Clear the command line screen on a Windows Computer
dip("Module Name") - Import a Python Module into Poison
math(First Number, Second Number, "+ or / or - or * or **") - Perform a Math equation
sq(Number) - Get the square root of a number
psn("Script name") - Execute a Python Script or Poison Script
execinpt("Prompt Text") - Get user input and execute it as a Poison Command or Python Command
numalph("Letter") - Convert a letter (lowercase or UPPERCASE) Into a Numerical Value
bye() - Exit Poison
download("File url to download", "File name to save as") - Download a file from the internet
There are a few other commands but they are not important however you can look them up if you wish they are not guaranteed to work properly.
category:languages
PokeType

A simple mathematical expression evaluator that uses Pokemon types to replace symbols.
== Syntax ==
=== Reference ===
Symbol	Math Equivalent	Pokemon Type
🔥 	+ 	Fire
🌊 	- 	Water
🪨 	* 	Rock
💨 	/ 	Flying
⚡ 	// 	Electric
☠️ 	% 	Poison
✊ 	> 	Fighting
🔮 	< 	Psychic
✨ 	== 	Normal
👻 	!= 	Ghost
🧚 	( 	Fairy
🌌 	) 	Dark
❄️() 	abs() 	Ice
⛓() 	log() 	Steel
🌿 	 	Grass
🐉 	>= 	Dragon
🏝️ 	<= 	Ground
🐛() 	^() 	Bug
=== Symbols Needed ===
Ran out of pokemon types, need help representing: >> <<
=== Data Types ===
* Numbers
* Boolean: “true” or “false”
== Examples ==
=== Basic Arithmetic ===
Addition:
1 🔥 1
Subtraction:
1 🌊 1
=== Comparisons/Boolean ===
Checking if numbers are equal:
1 ✨ 1
Is true >= false:
true 🐉 false
=== Functions ===
For Absolute of -2:
❄️🧚-2🌌
❄️(-2)
== Interpreter/Compiler ==
Using the installed python poketype package!
=== Syntax Checking ===
Check if PokeType expression is valid
from poketype import PokeType
pt = PokeType()
pt.check_syntax('code')
=== Interpret ===
Run code, and print output.
from poketype import PokeType
pt = PokeType()
print(pt.eval('code'))
=== Compile ===
Turn PokeType to python code
from poketype import PokeType
pt = PokeType()
print(pt.compile('code')) #Python
Category:Languages
Category:Implemented
Category:Thematic
Category:No IO
Category:Joke languages
Category:2021
Category:Unusable for programming
Category:Total
Pokecontest

Pokecontest is esolang with Graphical Output to a 16×16 grid made by Maikeru51. It's code is supposed to look like a transcript for a Pokemon contest.
==Pokemon and Moves==
Each program starts with each contestant's pokemon and said pokemon's moves listed. Each move is also given 5 categories, those being Cool, Beautiful, Cute, Clever, and Tough.
*If a move is "Cool", then the pointer moves backward one cell.
*If a move is "Beautiful", then the cell under the pointer increases it's Selected Value.
*If a move is "Cute", then the pointer moves foward one cell.
*If a move is "Clever", then the pointer switches between facing down and facing right. It also rotates between modifying cell's Red, Green, and Blue values every other use.
*If a move is "Tough", then the cell under the pointer decreases it's Selected Value.
Moves also have appeal levels. This determines how many times the action is done. Appeal levels must be a positive integer.
==How to Use Moves==
To use moves, type ***{Pokemon} used {Move}!*** If the pokemon does not know the move, or does not exist, the interpreter will throw an exception.
Category:LanguagesCategory:TotalCategory:ThematicCategory:UncomputableCategory:2021Category:Graphical OutputCategory:Unimplemented
PokéArena

Since there are over 400 Pokemon in existence, there should be a language including the first 256 in the National Dex.
Here's a (kinda broken right now) hello world:
 Trainer HELLOWORLD wants to battle!
 
 Go! NIDORINO!
 Go! VOLTORB!
 Go! LICKITUNG!
 Go! TANGELA!
 Go! RHYHORN!
 Go! SEAKING!
 Go! NIDORAN(male)!
 Go! RHYHORN!
 Go! LICKITUNG!
 Go! LICKITUNG!
 Go! ELECTRODE!
 Go! TENTACOOL!
 
 ((phrase to get a unicode string from stack)) 
 ((phrase to print))
 
 Player beat Trainer HELLOWORLD!
If someone can help me on this, I'd really appreciate it.
I have an idea: The commands are based on the types. I'm kinda lazy to list it to you (also, for multiple types, the first type is the one that is performed, it just ignores the second one.) ZachChecksOutEsolangs (talk)
Category:Ideas
Category:Languages
Policy Policy

Policy Policy is an esoteric programming language inspired by Baba Is You that allows modifying the rules. This is a set of rules for defining rules.
== Rules (WIP) ==
① There must be amending policies.
② Policies must execute sequentially.
== Make your language unusable ==
①X
Explanation:
# Amending rule 1.
① # For pre-existing rule 1:
 X # Invalidate this rule. (Negation)
== Hello, world ==
⒉R
Hello, world!
Explanation:
# Rule 1.
⒉R # Rule 2 must be read aloud.
# Rule 2.
Hello, world! # This has no effect, it is simply read aloud.
== Infinite output ==
⒊F∞
⒊R
?
Explanation:
⒊F∞ # Rule 3 shall be repeated infinity times.
⒊R # Rule 3 must be read aloud.
? # Output
Golfed:
⒉F∞;R
?
Explanation:
⒉F∞←R # ← refers to the firstly mentioned rule in this rule. This will make rules act like different rules.
?
↑ Previous rule for the previously mentioned rule. If there are no explicit mentions of rules, refer to the 1st rule.
↓ Next rule. If there are no explicit mentions of rules, refer to the last rule.
No mentions to refer to other rules in this rule? This auto-refers to the next rule. If the rule is out of bounds, then the number will be modulo'd by the number of amendment policies. The rule before the first rule is the last rule.
$ link with current item.
Golfed:
F∞←R
?
Explanation:
F∞←R # Repeat forever the next rule. Also must be read out loud.
?
Golfed:
↑ # First rule.
 F∞ # Repeat forever,
 ←R # And should be read out loud.
Category:Languages
Category:2019
Category:Unimplemented
Polyglot

A polyglot is a program that is acceptable to the specifications of more than one programming language. Usually, when executed, a polyglot does exactly the same thing in every language in which it can be run.
There's also special form of polyglot, which is a mixture of polyglot and quine: a polyglot quine. Polyglot quines are mostly more complicated to write than normal polyglot programs due the nature of a quine. Naturally polyglot quines need to produce the exactly same output in every language part of the polyglot quine.
==External resources==
* The Polyglot List - Contains a selection of polyglots.
* Esoteric 7 language polyglot - Works in Malbolge, Brainfuck, Whitespace, Spoon, Asdf, 123 and EXCON.
* - Prints Hello, world! in Befunge, Brainfuck, Chef, Kipple and ORK.
* PPCG's answer chaining polyglot (451 languages as of 2024-09-11)
* An introduction into quines and polyglots - Contains a nice Polyglot Quine written in C, Python and Shellscript
Category:Program forms
* 4 esolang + Python polyglot is a simple polyglot that works in Befunge, brainfuck, Deadfish~, oOo CODE and Python.
* 7 esolang + Python polyglot prints in BFFuck, Python, Brainfuck, Befunge-93, PlusOrMinus, Deadfish, Alphuck, and oOo CODE.
Poochiewuddledumpling-Boobledarling

Poochiewuddledumpling-Boobledarling is a programming language loosely based on assembly. It was created by two Finnish coders. The first usable beta version came out in July 2009.
== Syntax ==
Descriptions coming soonwho knows when!
mov
add
sub
mul
div
rnd
push
pop
empty
inv
copy
dump
jmp
cmp
je
jne
jg
jge
jng
jnge
jl
jle
jnl
jnle
call
ret
in
out
alloc
sys
loc
col
end
== Sample programs ==
=== Using functions ===
jmp Main
;Adds 1 to the EAX register
Plus:
 add EAX $1
ret
;Main program
Main:
 call Plus
 call Plus
 call Plus
 ;The ASCII character of 0 is 48
 add EAX $48
 out 0 EAX ;Print the number
 out 0 $13 ;Carriage return
 out 0 $10 ;Newline
end
=== 99 bottles of beer ===
mov EBX $99
jmp Main
Print:
 inv ;Invert the stack
 Print_Loop:
 pop EAX ;Take one character from the stack
 
 ;Replace _ with space
 cmp EAX $95
 jne Cont
 mov EAX $32
 Cont:
 
 out 0 EAX ;Print the character
 empty EAX ;Check is the stack empty
 cmp EAX $0
 je Print_Loop
 ;New line
 out 0 $13
 out 0 $10
ret
Number:
 mov ECX EBX
 
 cmp ECX $0
 jne NotZero
 dump "no_more"
 jmp EndNumber
 
 NotZero:
 cmp ECX $10 ;Is less that 10
 jl One
 
 ;Printed number is greater that 9
 mov EDX ECX
 div EDX $10
 mov EAX EDX
 add EDX $48
 push EDX
 mul EAX $10
 sub ECX EAX
 add ECX $48
 push ECX
 jmp EndNumber
 
 ;Printed number is less that 10
 One:
 add ECX $48
 push ECX
 EndNumber:
ret
Throw_Bottle:
 call Number
 dump "_bottles_of_beer_on_the_wall,_"
 call Number
 dump "_bottles_of_beer."
 call Print
 sub EBX $1
 dump "Take_one_down_and_pass_it_around,_"
 call Number
 dump "_bottles_of_beer_on_the_wall."
 call Print
 
 ;New line
 out 0 $13
 out 0 $10
ret
Main:
 call Throw_Bottle
 cmp EBX $0
 jne Main
 
 dump "No_more_bottles_of_beer_on_the_wall,_no_more_bottles_of_beer."
 call Print
 dump "Go_to_the_store_and_buy_some_more,_99_bottles_of_beer_on_the_wall."
 call Print
 out 0 $13
 out 0 $10
end
Category:Languages
Category:2009
Category:Low-level
Poohbear

Poohbear is a cell-based language largely inspired by brainfuck. It has a maximum integer value of 255, and 30,000 cells. The original intention of Poohbear was to be able to send messages that would, to most, be completely indecipherable.
== Commands ==
Command	Definition
+ 	Add 1 to the current cell
- 	Subtract 1 from the current cell
> 	Move the cell pointer 1 space to the right
< 	Move the cell pointer 1 space to the left
c 	"Copy" the current cell
p 	Paste the "copied" cell into the current cell
W 	While loop - While the current cell is not equal to 0
E 	Closing character for loops
P 	Output the current cell's value as ascii
N 	Output the current cell's value as an integer
T 	Multiply the current cell by 2
Q 	Square the current cell
U 	Square root the current cell's value
L 	Add 2 to the current cell
I 	Subtract 2 from the current cell
V 	Divide the current cell by 2
A 	Add the copied value to the current cell's value
B 	Subtract the copied value from the current cell's value
Y 	Multiply the current cell's value by the copied value
D 	Divide the current cell's value by the copied value.
== Examples ==
Although there are many ways to do the same thing, here are some examples. The following is a Hello World Program:
 +LTQTP>LL+TQ+P>LLT-c<APP>IIc<AP>I->+LLT+TTP<+LLTLc>BP>+LQQLLLP<<<PL+PIIIPIIIIP>>>>LLQT+P
There's nothing too complicated in this example.
A program that outputs all printable ASCII characters:
 +LTQIIWP+E
This program starts at a value of 32, the first printable ASCII character. Then it increments by 1 every loop until it reaches 0 and the loop closes.
A program that prints numbers from 1-255:
 +LTQII>+WN<P>+E
 
The first section stores 32, which in ASCII is a space. Then it adds one to the next cell, and goes through all the numbers until it wraps back to zero and the loop closes.
== Interpreters ==
An interpreter for Poohbear was written in C, which worked by rewriting the input program and converting it to its C equivalent, and then compiling and running it.
That interpreter can be found here.. To run a .pb file, open the command prompt in the folder, and type poohbear file.pb.
Category:Languages Category:Turing complete Category:2017 Category:Cell-based Category:Implemented
Poololoop

Poololoop is a programming language whose source code is the programmer running a path, measured with a GPS. The loops in the running path encode a lambda calculus program. The language is defined in this article:
George(s) Zakhour, “Getting Up and Running the λ-Calculus”, in a record of the proceedings of SIGBOVIK 2024 the eigtheenth annual intercalary robot dance party in celebration of workshop on symposium about 26th birthdays; in particular that of Harry Q. Bovik, p. 23., Carnegie Mellon University, ed. The Association for Computational Heresy, Pittsburgh, PA, April 0, 2024.
Category:Languages
Category:2024
Category:Turing complete
Category:No IO
Category:Implemented
Category:Non-textual
Category:Functional paradigm
Poop

Poop is an esoteric programming language made by Eike Tim Jesinghaus in April 2014. Poop is unusable for programming, because it's just a joke/fun language.
== Overview ==
Poop 1.0 has only six commands:
Command	Description
eat 	Move the pointer to the right
puke 	Move the pointer to the left
poop 	Add pointed character to the string
POOP 	Add pointed character to the string uppercased
sniff 	Show the string
flush 	Empty the string and set pointer to 0
List of characters for Poop 1.0
0123456789abcdefghijklmnopqrstuvwxyz.,-!?+*<>#@$€§%&/()[]
== Hello World ==
 eat eat eat eat eat eat eat eat eat
 
 eat eat eat eat eat eat eat eat
 
 POOP
 
 puke puke puke
 
 poop
 
 eat eat eat eat eat eat eat
 
 poop
 
 poop
 
 eat eat eat
 
 poop
 
 sniff
 
 flush
 
 eat eat eat eat eat eat eat eat eat
 
 eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat
 
 POOP
 
 puke puke puke puke puke puke puke puke
 
 poop
 
 eat eat eat
 
 poop
 
 puke puke puke puke puke puke
 
 poop
 
 puke puke puke puke puke puke puke puke
 
 poop
 
 eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat
 
 poop
 
 sniff
== Interpreter ==
Download: Python Interpreter (Source): http://www.mediafire.com/download/c5amf35t5w858bc/Poop1.0-PythonInterpreter.zip
Download: Python Interpreter (Windows .exe): http://www.mediafire.com/download/88ee2v4ze8bdfoa/Poop1.0-PythonInterpreter+WinExe.zip
When you run it, the interpreter will ask for a file to run. Type in the location of your script. Press ENTER, and the interpreter will run the program with Poop.
== Tools ==
=== poopOut ===
"poopOut" is a String to Poop converter written by Maximilian Krause (aka fucketh1cs) in Java. It's capable of getting a String through a file and outputting the equivalent for Poop 1.0 into another file. This makes it easy to output big texts through Poop, like "99 bottles of beer".
Download: http://www.file-upload.net/download-11026061/poopOut.jar.html
Source code: http://pastebin.com/JhqT7fKU
99 bottles of beer (shortened version): http://pastebin.com/w3x2Lpw8
Category:Languages Category:Joke languages Category:2014 Category:Implemented
PopFuck

PopFuck is a esolang made by Mihai Popa. It's a smaller and a "crappier" version of Brainfuck.
Any other character than these in the table is a NOP (comment).
== Command Table ==
 Command Table
Command	Meaning
+ 	Increment a step
5 	Increment 5 steps
0 	Increment 10 steps
> 	Output character as ASCII then move to the next character (cell).
== Examples ==
=== Hello, world! ===
0000000++>0000000000+>00000000005+++>00000000005+++>00000000000+>0000++++>000++>000000000005++++>00000000000+>00000000000++++>00000000005+++>0000000000>000+++>
or, if you want somewhat more descriptive:
Hello, world! in PopFuck:
Prints the message "Hello, world!" to console output.
0000000++>0000000000+>00000000005+++>00000000005+++>00000000000+>0000++++>000++>000000000005++++>00000000000+>00000000000++++>00000000005+++>0000000000>000+++>
=== XKCD Random Number ===
00000++>
=== Rickroll ===
So large, posted on PopFuck/Rickroll
All these was generated using the PopFuck generator using maximum optimization.
== Interpreter (also doubles as a generator) ==
See this.
Category:Languages
Category:2024
Category:Implemented
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
Poplang

Esoteric programming language I made called poplang:
= Info =
== Rules ==
These are the rules of Poplang
 >(a) = a
 a = (a) or >a or or (ab) or >
 b = (b) or >b or or (ba) or >
 (a)(b) = (ab)
 (>)(a) = >a
Category:Languages