nyuuzyou/wikis huggingface dataset:
PlusOrMinus 2

PlusOrMinus 2 is a fungeoid esolang created by User:PythonshellDebugwindow. It is a two-dimensional adaptation of PlusOrMinus.
==Memory==
Like PlusOrMinus, PlusOrMinus 2 uses an unsigned wrapping 8-bit accumulator which starts at zero.
==Instruction pointer==
PlusOrMinus 2 uses an instruction pointer which can travel up, right, down, or left. It starts at the top-left corner of the program, and is initially travelling to the right. If the instruction pointer goes out of bounds, then the program exits without raising an error.
==Commands==
Command	Effect
+ 	Increments the accumulator.
- 	Outputs the Unicode character whose codepoint is equal to the value of the accumulator, then decrements the accumulator.
^ 	Makes the instruction pointer travel upwards.
> 	Makes the instruction pointer travel to the right.
V 	Makes the instruction pointer travel downwards.
< 	Makes the instruction pointer travel to the left.
| 	If the accumulator is equal to zero, then the instruction pointer begins travelling downwards.
All other characters, when encountered by the instruction pointer, cause the program to raise an error and exit.
==Auto-formatting==
Before execution of the program begins, each row will be truncated so that it is only as long as the shortest row; the same is true of columns. Trailing whitespace is ignored when finding the shortest row and column.
For example, the following program:
 ABCDEFG
 HIJKL M
 NOPQRSTUV
 WX Y
 Z
would be truncated to:
 ABCD
 HIJK
 NOPQ
because the shortest row (   Z) is four characters long and the shortest column when trailing whitespace is ignored (AHM) is three characters long.
The lengths of the shortest row and column are calculated before truncation takes place. For example, the following program:
 AB
 C D
 E
would be truncated to:
 AB
 C 
with a trailing space on the second line.
==Examples==
===Truth-machine===
Replace the first + on the second line with > for input 0. Here, the code for input 1 is shown.
 V V<<<
 >+|>+++++++++++++++++++++++++++++++++++++++++++++++++>-+^
 ..>++++++++++++++++++++++++++++++++++++++++++++++++->>>>>
==Resources==
* An interpreter written in Python
Category:2020 Category:Languages Category:Implemented Category:Two-dimensional languages Category:Finite state automata Category:Unusable for programming
Plushie-complete

As stated by User:Cinnamony:
 a language is only plushie-complete if it follows a set of rules created by one of my dragon plushies
==Rules==
# It must be able to print the number 4.
# It must be able to print the number 31.
# It must be able to store 2 in a variable.
There, those are the only 3 rules.
==Requirement==
That is, if an Esolang is Plushie-complete, then it can support I/O or variable.
==Pseudo code==
i = 2
print i * 2
print 31
Category:Concepts
Pluso

Pluso is an esoteric programming language created by User:Icepy in 2014. This programming language is called pluso because it has two commands: plus and output. The o standing for output, of course. The only data structure in pluso is an accumulator.
== Storage ==
Pluso has a single accumulator, which can hold the integer values 0–26.
The initial value of the accumulator is 1.
== Commands ==
Command	Action
p 	increment the accumulator, modulo 27
o 	output the value of the accumulator, according to the Pluso charset
The reference implementation ignores any non-command characters in the input file.
== Charset ==
Output uses the Pluso charset:
Value	Character 	ASCII code	ASCII code
0 	space 	32 	0x20
1 	uppercase A	65 	0x41
2 	uppercase B	66 	0x42
... 	... 	... 	...
25 	uppercase Y	89 	0x59
26 	uppercase Z	90 	0x5A
== Examples ==
=== Hello world ===
pppppppo
ppppppppppppppppppppppppo
pppppppoo
pppo
ppppppppppppo
pppppppppppppppppppppppo
pppppppppppppppppppo
pppo
pppppppppppppppppppppo
pppppppppppppppppppo
This will print HELLO WORLD
== Implementations ==
=== Python ===
def run(file):
 acc = 65
 file = open(file)
 prgm = file.readlines()
 for line in prgm:
 for cmd in line:
 if cmd == 'p':
 acc += 1
 elif cmd == 'o':
 char = chr(acc)
 print(char, end=)
 if acc == 91:
 acc = 32
 elif acc == 33:
 acc = 65
===Ruby===
 eval'c=1;'+ARGF.read.gsub(/./,'p'=>'c=(c+1)%27;','o'=>'putc c!=0?c+64:32;')
Category: Languages
Category: Joke languages
Category: Unusable for programming
Category: Implemented
Category: Output only
Category: 2020
Category: Total
PocketBF

PocketBF is a tinyBF derivative with a dedicated I/O command.
==Commands==
Command 	Effect if the direction is… 	Effect if the direction is…
Command 	positive 	negative
= 	Switch the direction from positive to negative. 	Switch the direction from negative to positive.
Increment the current cell by one.brainfuck equivalent: +.	Decrement the current cell by one.brainfuck equivalent: -. 	
> 	Move the cell pointer one step to the right.brainfuck equivalent: >. 	Move the cell pointer one step to the left.brainfuck equivalent: <.
 	.brainfuck equivalent: [. 	.brainfuck equivalent: ].
; 	If the current cell value equals zero, query the user for an input character and store its ASCII code in the current cell. Otherwise, output the character corresponding to the current cell value construed as an ASCII code.Approximate brainfuck equivalents: , and ..	If the current cell value equals zero, query the user for an input character and store its ASCII code in the current cell. Otherwise, output the character corresponding to the current cell value construed as an ASCII code.Approximate brainfuck equivalents: , and ..
==Examples==
===Cat program===
An infinitely repeating cat program is implemented in the following:
 +|=+=;=;=|=+|=+=|
==See also==
Related programming languages comprehend:
* InstructionPointerBF, a binary encoding of PocketBF
* tinyBF, the inspiration for this language
==Interpreter==
* Common Lisp implementation of the InstructionPointerBF programming language. The program also contains a PocketBF interpreter, given their consanguinity.
Category:Languages
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Implemented
PocketFuck

PocketFuck is an image version of brainfuck by User:None1. Programs in this esolang are small enough to be put in your pocket!
==How to write Programs==
To write a program in PocketFuck, first write a program in brainfuck, and pad it in the end with the + instruction until the number of instructions is divisible by 8, then convert every instruction into 3 binary bits using the table below.
 Binary Conversion
Binary Conversion	brainfuck
000 	+
001 	-
010 	>
011 	<
100 	,
101 	.
110 	[
111 	]
Then group the binary bits 24 by 24, every 24 bits stands for the RGB value (e.g.: 100110101100111000000000 becomes (154, 206, 0)) of a pixel in the image.
Finally, arrange the pixels into an image, starting from the top left corner, going right then restarting at the next line from the left.
Unlike other brainfuck-based image esolangs, PocketFuck uses every bit in every pixel to store instructions, allowing it to be very space-efficient.
As every bit in the image counts, you must use lossless image formats, like PNG.
==Example Programs==
===Cat Program===
The cat program in this esolang is 1 pixel large
===Hello World===
===XKCD Random Number===
===Nope. interpreter===
===Truth Machine===
===dbfi based brainfuck interpreter===
==Turing completeness==
Since brainfuck is Turing complete, this esolang is also Turing complete.
==Interpreters==
The following is the official interpreter in Python, which also provides conversion from and to brainfuck.
from PIL import Image
import numpy as np
import sys
def bf(code):
 s1=[]
 s2=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='[':
 s1.append(i)
 if j==']':
 m=s1.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='+':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='-':
 tape[p]=(tape[p]-1)%256
 if code[cp]==',':
 ch=sys.stdin.read(1)
 tape[p]=(ord(ch) if ch else 0)%256
 if code[cp]=='.':
 print(chr(tape[p]),end=)
 if code[cp]=='<':
 p-=1
 if code[cp]=='>':
 p+=1
 if code[cp]=='[':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]==']':
 if tape[p]:
 cp=matches[cp]
 cp+=1
def bf2pf(bf):
 f='+-><,.[]'
 s=''
 for i in bf:
 s+='{:03b}'.format(f.index(i))
 s=s+'0'*((-len(s))%24)
 pixels=[]
 for i in range(len(s)//24):
 pixels.append([int(s[i*24:i*24+8],2),int(s[i*24+8:i*24+16],2),int(s[i*24+16:i*24+24],2)])
 return Image.fromarray(np.array([pixels],dtype=np.uint8))
def pf2bf(pf):
 prog=''
 tmp=''
 if pf.mode!='RGB':
 print('PocketFuck only supports RGB images')
 return ''
 dat=pf.tobytes()
 for i in dat:
 tmp+='{:08b}'.format(i)
 for i in range(len(tmp)//3):
 prog+='+-><,.[]'[int(tmp[i*3:i*3+3],2)]
 return prog
if __name__=='__main__':
 bf(pf2bf(Image.open(sys.argv[1])))
It requires the Python Imaging Library and NumPy.
==See also==
* Brainstoremax
Category:Languages
Category:Non-textual
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Turing complete
Category:Implemented
Category:2023
Poetic.BCT

Poetic.BCT is a language made by Unname4798 and a member of the Poetic family.
== Commands ==
This language encodes commands as the word length mod 2. Alphabetic characters are in the word, other characters act as delimiters.
All commands are the same as in BCT.
==Converter to BCT==
Written in JavaScript.
const poeticBctToBct = program => program.split(/\W+/g).filter(x => x).map(x => x.length % 2).join("");
Category:2024
Category:Languages
Category:Turing complete
Category:Pseudonatural
Category:Implemented
Poetic/Interpreter

:
:
This is a:
* Poetic interpreter
* PoeticFuck interpreter
* Poetic to PoeticFuck translator
by User:None1 in Python.
import sys
from random import randint
def p2pf(code): # Translates Poetic to PoeticFuck
 res=''
 while code:
 p=0
 q=0
 while p<len(code) and code[p] in "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'":
 q+=code[p].isalpha()
 p+=1
 if q: 
 if q==10:
 res+='0'
 else:
 res+=str(q)
 while p<len(code) and code[p] not in "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'":
 p+=1
 code=code[p:]
 r=''
 while res:
 if res[0] in '3456':
 try:
 r+=';[]+-><.,?'[int(res[0])]*(int(res[1]) if int(res[1]) else 10)
 res=res[2:]
 except:
 break
 else:
 r+=';[]+-><.,?'[int(res[0])]
 res=res[1:]
 return r
def pf(code): # Interprets PoeticFuck
 s=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='[':
 s.append(i)
 if j==']':
 m=s.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='+':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='-':
 tape[p]=(tape[p]-1)%256
 if code[cp]==',':
 c=sys.stdin.read(1)
 tape[p]=(ord(c) if c else tape[p])%256
 if code[cp]=='.':
 print(chr(tape[p]),end=)
 if code[cp]=='<':
 p-=1
 if code[cp]=='>':
 p+=1
 if code[cp]=='[':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]==']':
 if tape[p]:
 cp=matches[cp]
 if code[cp]=='?':
 tape[p]=randint(0,255)
 if code[cp]==';':
 return
 cp+=1
if __name__=='__main__': # Direct execution: Interprets Poetic
 pf(p2pf(sys.stdin.read()))
Category:Implementations
PoeticFuck

==Instructions==
PoeticFuck	Poetic Digit equivalent	Meaning
; 	0 	End program execution here.
[ 	1 	If the current byte is equal to 0, jump execution to after the matching [.
] 	2 	If the current byte is not equal to 0, jump execution to the matching [.
+ 	3* 	Increment cell under pointer
- 	4* 	Decrement cell under pointer
> 	5* 	Increment pointer
< 	6* 	Decrement pointer
. 	7 	Output the value of the current byte as an ASCII character.
, 	8 	Read a character from the input stream, and write its ASCII value to the current byte. (Note: This fails to update the current byte upon end of input.)
? 	9 	Set the current byte to a random value from 0 to 255.
* These commands have an argument: the value to increment or decrement, when translating from digits to PoeticFuck, they should get expanded (e.g.: 35 to +++++)
==Examples==
===Hello World!===
 ++++++++++[>+++++++>++++++++++>+++>+++++++++>+<<<<<-]>++.>+.+++++++..+++.>++.>---.<<.+++.------.--------.>+.>>.;
===Cat===
 ,[.[-],];
===Reverse cat===
 ,[>,]<[.<];
===ASCII Loop===
 --[>>>>>>>+.<<<<<<<]
===Random Number===
 ?[>+>+<<-]>[<+>><-]++++++>[<------>[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]++++++++[>++++++<-]>>]>]<[[>>>++++++++<<<-]>>>>]<[.[-]<<<<<<>>>];
==Interpreters==
* Poetic/Interpreter
Category:Languages
Category:2024
Category:Brainfuck derivatives
Category:Implemented
Poetic (family)

Poetic is a family.
== Description ==
The esolangs in this family encode commands as word lengths. Alphabetic characters and (optionally) apostrophes are in the word, other characters act as delimiters.
== Esolangs in this family ==
* Poetic
* Poetic.BCT
* 2 poets, 1 poem
* Slam
* Poetic LOLWICNETP
* Word%66uck
* Tahled
== Esolangs in this family, but in foreign languages ==
* 诗(None1)
* 诗(PSTF)
* 诗(islptng)
Poetic LOLWICNETP

== Commands ==
1-2 letters: (x, y) Increase x's value by y
3 letters: (x, y) Decrease x's value by y
4 letters: (x) Set a variable x to user input (number)
5 letters: (x) Output x as a number
6 letters: (x) Output x as an ASCII character
7 letters: (x, y) Start (while x=y-1) loop
8+ letters: End while loop
== Truth machine ==
 Work, machine!
 Truth machine!
 Machine, machine, on!
 Truth machine!
 Pancakes!
Category:Unimplemented Category:2024 Category:Joke languages Category:Pseudonatural
Poetic is plushie-complete

Even though User:Ais523 has requested me not to use the category for plushie-completeness anymore, and Poetic is already known to be plushie-complete because BF is plushie-completeBF is Plushie-complete, I would still really like to make this page.
==Rule 1==
 And the hen eat lot. I think the ten hen pen can pee the Lee out yea. Loves yous all soo severly. 
==Rule 2==
 And the hen eat lot. I think the ten hen pen can pee the Lee out yea. Loves yous severly like sooo severly.
==Rule 3==
 You col.
==Conclusion==
Poetic is plushie-complete.
==Ref table==
Category:2023Category:Proofs
Point

Point is a stack-based esoteric programming language, initially inspired by Befunge and Glass.
==Overview==
As from version 0.0.1, a Point program executes instructions on a stack. The stack can contain only integers, which can be used to represent both integers and ASCII characters. All instructions are characters. Some of them depend on others to complete their tasks, like ( and ).
==Instructions==
Instruction 	Description
0..9 	Push digit as an integer onto stack if not scanning integer.
( 	Enable integer scanning.
) 	Disable integer scanning.
" 	Toggle string scanning; if toggled off, push 0.
[ 	Enable loop scanning.
] 	Disable loop scanning, and start scanned loop.
Pop top two items from stack. Add them. Push result onto stack. 	
Pop top two items from stack. Subtract the first one from the the second one. Push result onto stack.	
* 	Pop top two items from stack. Multiply them. Push result onto stack.
/ 	Pop top two items from stack. Divide the second one by the the first one. Push result onto stack.
% 	Pop top two items from stack. Divide the second one by the first one. Push remainder onto stack.
^ 	Discard top item from stack.
= 	Duplicate top item of stack.
~ 	Swap top two items of stack.
> 	Rotate stack to the right.
< 	Rotate stack to the left.
$ 	Clear stack.
# 	Push size of stack.
? 	Pop item from stack. If its value is zero, push 1, otherwise push 0.
. 	Pop item from stack and output it as an ASCII character.
: 	Pop item from stack and output it as an integer.
, 	Push item from input as an ASCII character onto stack.
; 	Push item from input as an integer onto stack.
& 	Exit program.
==In-depth==
( enables number scanning. When it's enabled, every scanned digit gets pushed onto the stack, then multiplied by 10 and added to the next digit (if there is one) before .. All that before ) which disables number scanning.
" enables string scanning. When it's enabled, all scanned characters get pushed onto the stack in reverse (unlike Befunge, ugh) before ", which disables string scanning. When string scanning is disabled, 0 gets pushed onto the stack, to indicate the end of the string (which is just characters followed by 0; possibly just 0).
[ enables loop scanning. When it's enabled, every scanned character gets executed as an instruction from the start of the loop, until the top item of the stack is not null, then that top item is discarded (popped without use). ] disables loop scanning.
Other instructions are self-explanatory from the table above.
==Examples==
===Hello, world!===
 "Hello, Point!"[.]
Note that [.] recursively pops and prints the top item (which is a character pushed by scanning the string "Hello, Point!") as an ASCII character until it's 0, which at that point gets discarded.
===Countdown===
 (10)[=:1-" "[.]]
Here, 10 is the number which will be decremented until reaching 1.
===Counting up===
 0=[^=:1+=(10)~-1+" "[.]]
And here, 10 is the number which will be counted to, starting from 0.
Category:Languages
Category:2019
Category:Stack-based
Category:Turing complete
Point Break

Point Break is an esolang by User:PythonshellDebugwindow.
==Storage==
Point Break uses a variable system. Variables can hold unbounded signed integers.
==Commands==
Point Break has only four commands: LET, POINT, BREAK, and END. As well as this, # denotes a line comment.
===LET===
LET takes the syntax of LET var:=expr. It sets the variable var to the result of expr, where var is a series of lowercase letters. expr can be either a variable, a number, or an expression, which is a series of operator-separated variables and/or numbers (operators are + for addition, - for subtraction, * for multiplication, and / for integer division). ? can replace a number, and represents a number input by the user.
===POINT===
POINT takes the syntax of POINT label. It opens a new infinite loop with the label label, where label is a series of lowercase letters. Loops cannot be empty.
===BREAK===
BREAK takes the syntax of IF var BREAK label. Where var and label are both series of lowercase letters, it breaks out of the loop labeled label, as well as all its child loops and their (recursive) children.
===END===
END takes the syntax of END label. It closes the loop with the label label, as well as all its child loops and their (recursive) children (ends children as well to shorten code).
==Examples==
===Infinite loop===
 LET zero:=0
 POINT loop
 IF zero BREAK loop
 END loop
===Truth-machine===
 LET n:=?
 LET one:=1
 POINT truth
 POINT check
 IF n BREAK check
 IF one BREAK truth
 END truth
==Computational class==
Point Break is Turing-complete, as it can simulate a Minsky machine. LET x:=x+1 to increment, LET x:=x-1 to decrement. While loops can be achieved; the following does <code> while user input is nonzero (do not change constantone):
 LET n:=?
 LET constantone:=1
 POINT while
 POINT check
 IF n BREAK check
 IF constantone BREAK while
 END check
 <code>
 END while
This loop can be modified to use any condition, not just user input.
Category:Languages Category:2020 Category:Unimplemented Category:Turing complete Category:Turing tarpits
Point operator

The point operator is an incredibly stupid (read: "New and eso") operator invented by User:Hppavilion1 in November of 2015 in an attempt to make floating point literals unnecessary for lexing for a new non-esolang he was working on. It was all well and good until Tanner Swett spoiled everything.
== Idea ==
The point operator was to be a replacement for the standard token "3.5" (or similar-form number). Instead of simply detecting floats matching that syntax, the lexer would recognize two integers, along with a "." operator between them. The parser would join these (. would have very high precedence) into a single expression that the executioner would then convert to a float with an integer part of the left-hand side and a decimal part of the right-hand side.
Making . an operator would have allowed users to do things such as (x+y).5 or x.y or 0x3.5, which would have been useful in a few niche cases. The last one gets confusing, as the left-hand side is interpreted as a hex literal but the right-hand side is not, but it would've been cool. Alas, it was not to be. Fuckin' human notation.
== Pitfall ==
To see the problem with the point operator, consider the expression 3.05. Since both sides are treated as integers, 3.05 is equivalent to 3.5, or truly any number of leading zeros for the decimal part are ignored. Tanner Swett came up with a few rather eso- solutions, such as making an infinite number of operators of the form {".", ".0", ".00", ".000"...}, but the language the author was attempting to develop was intended to be usable and rational while still channeling Hedwig Notta; not weird and insane in every way. Still, the . operator may live on into the language for making floating point values without leading zeros, if the author is feeling particularly strange that day.
Category:Ideas
Pointer-based Minsky machine

Pointer-based Minsky machine is a computational model created by User:Ractangle. It's basically just a General Minsky Machine but instead of using registries as arguments in commands. You instead just use the good'ol pointer that points to a registry
==The notation==
Command	Action
A 	Adds a registry to the pointer stack
R 	Moves the registry pointer to the right
L 	Moves the registry pointer to the left
I 	Increments the current pointing registry
D 	Decrements the current pointing registry is the current pointing registry is not 0. If the current pointing registry is 0. It checks the n th registry (specified by the argument next to ) and goes to command n (spefied by the n th value of the cell)
==Implementations==
===Python===
 def PBMM(c):
 p=0;r=[0];pos=0
 while p<len(c):
 if c[p]=="A":r.append(0)
 elif c[p]=="R":pos+=1
 elif c[p]=="L":pos-=1
 elif c[p]=="I":r[pos]+=1
 elif c[p]=="D":
 if r[pos]>0:r[pos]-=1
 else:p=r[int(c[p+1])]-1
==Computational class==
This variant of a Minsky machine might be able to simulate a turing machine. Although it is not proven yet
Category:Computational models
Pointer-ng

pointer-ng is an extended version of Brainfuck by Maximilian Krause (aka fucketh1cs) who also wrote an interpreter for it. pointer-ng is a superset of Brainfuck, therefore every Brainfuck code is valid in pointer-ng as well. However, pointer-ng offers several more features which make coding in Brainfuck a little easier. The added features contain for example networking, IO and randomness.
== pointer-ng Commands ==
Symbol 	Feature
<>+-.,[]	Brainfuck equivalent.
| 	Opens or closes a comment. Spaces however are not permitted within a comment. Use underscores _ instead.
~ 	Switches [dir] from home directory to script startup path or the other way for the commands accessing the IO filesystem.
# 	Reads [dir]/input.ptng and puts all the content in the cells to the right. The pointer is set to the end.
$ 	Appends the content of the current cell into [dir]/output.ptng.
v 	Downloads the content from the URL in [dir]/inurl.ptng and writes all the content in the cells to the right. The pointer is set to the end.
^ 	Sends a POST header with the content output:[current cell value] to the URL in [dir]/outurl.ptng.
* 	Performs the operation [right cell]=[current cell]*[left cell].
/ 	Performs the operation [right cell]=[current cell]/[left cell].
" 	Performs the operation [right cell]=[current cell]+[left cell].
' 	Performs the operation [right cell]=[current cell]-[left cell].
% 	Performs the operation [right cell]=[current cell] mod [left cell].
! 	Performs the operation [right cell]=[current cell]*10.
? 	Performs the operation [right cell]=floor([current cell]/10).
& 	Zeroes the current cell.
@ 	Puts a random number between (incl.) 0 and (incl.) 10 into the current cell.
_ 	Performs the operation [current cell]=-1*[current cell].
: 	Prints the content of the current cell as an integer.
== Example Code ==
Calculate (5+5)*10 and output the result:
+++++>+++++">!>:
Take two inputs and print the sum (up to 127):
+++++++++++!>.&<&+:&+++++!>++++++++.&<&+++!>++.&<&;>+++++++++++!>.&<&++:&+++++!>++++++++.&<&+++!>++.&<&;>+++++++++++!>++++.&<&+++++!>++++++++.&<&+++!>++.&<&<">:
== Interpreters ==
Official interpreter (Java needed)
Download: https://www.dropbox.com/s/hcm80qvwcw59m5q/pointer-ng.jar?dl=0
Source: https://github.com/fucketh1cs/pointer-ng
Usage: java -jar pointer-ng.jar [*.ptng script]
Category:Brainfuck_derivatives
Category:Languages