nyuuzyou/wikis huggingface dataset:
PROGRAMCODEYOU

PROGRAMCODEYOU is a version of SovietCode by User:Tommyaweosme
== Commands ==
 IN AMERICA, - optional. backwards version of script where everything is like it should be
 IN SOVIET RUSSIA, - starts scripts
 MEMORY CELL MOVE YOU!!! - moves memory pointer to right
 MEMORY CELL MOVE YOU BACK!!! - moves memory pointer to left
 WHEN NOT 0 IS CELL, ()!!! - brackets in brainfuck
 CELL INCREMENT YOU!!! - adds one to cell
 CELL DECREMENT YOU!!! - subtracts one to cell
 OUTPUT IS CELL!!! - outputs current cell as ascii
 CELL ENTER INPUT!!! - ascii input into cell
== Turing-completeness proof ==
 > MEMORY CELL MOVE YOU!!!
 < MEMORY CELL MOVE YOU BACK!!!
 [ WHEN NOT 0 IS CELL, (
 ] )!!!
 + CELL INCREMENT YOU!!!
 - CELL DECREMENT YOU!!!
 . OUTPUT IS CELL!!!
 , CELL ENTER INPUT!!!
== Ascii loop ==
 IN AMERICA,
 YOU INCREMENT CELL
 WHEN CELL IS NOT 0, (
 CELL IS OUTPUT
 YOU INCREMENT CELL
 )
 IN SOVIET RUSSIA,
 CELL INCREMENT YOU!!!
 WHEN NOT 0 IS CELL, (
 OUTPUT IS CELL!!!
 CELL INCREMENT YOU!!!
 )!!!
PROLAN/M

PROLAN/M is the language described in one of the problems of the 2nd International Olympiad in Infomatics in 1990. Its programs are essentially sequential substitution systems, a string-rewriting paradigm.
The language is much like Thue. The code consists of a list of substitution rules of the form
 (<original string>,<replacement string>)
which is terminated with
 (,)
PROLAN/M programs are run as follows. First, the input string is retrieved, perhaps from the user or another program. Second, each of the substitution rules is tried from top to bottom until one matches, in which case the substitution is made, or all rules are exhausted. This second step is repeated as long as at least one rule matches. When no more rules match, the string in its final form is printed out, and the program terminates.
Only one substitution is made at a time. That is, if the substitution
 (e,o)
is run on the string "beet pies", the result is "boet pies", not "boot pios".
Note that PROLAN/M has no input or output instructions. Instead, it simply operates on a single string, which at the beginning of the program is input, and at the end of the program is output.
==Computational class==
Because PROLAN/M is almost equivalent to Thue, we can show that it is Turing-complete.
==External resources==
Note that the example in the problem description below has a typo. The string would be rewritten from "aad" to "bd", not "aad" to "db", but the output of the example program is still "finish".
* 2nd International Olympiad in Informatics Problems
** HTML 1
** HTML 2
** PDF
* A solution to the sum problem
* 
* Interpreter in C
* Sequential substitution systems at Mathworld.
Category:Languages
Category:String-rewriting paradigm
Category:Implemented
Category:Turing complete
Category:Before 1993
PSOX/PRI

This page is a table of registered PSOX Resource Identifiers. All registered PRIs begin with pri:
PRI 	Type 	Description 	Registrant
pri:exdom 	Custom Domain 	The example domain included in the PSOX.py interpreter 	Sgeo
pri:PSOX.py	Server Handprint 	Handprint for PSOX.py 	Sgeo
pri:. 	Testing/Private Use	All PRIs beginning with "pri:." or with a NUL are reserved for testing/private use	Sgeo
pri:GUI 	Custom Domain 	(soon-to-be) Included GUI domain for PSOX 	Sgeo
PSTF

PSTF is an Esoalng designed by PSTF.
== Original Commands ==
# All commands in Python.
# execute(language, script) executes the script by language.
# install(packname) installs packname with pip. If failed to install, skip next command line.
# === -Change to [language name]- === some code=== END === executes the code between two boundaries with language_name. If the language doesn't exist, raise an ERROR.
== Additions ==
Write your command here.
== Example ==
=== Hello, world! ===
=== -Change to [BFInfinity]- ===
+++++++++++
[
 >++++++
 >+++++++++
 >++++++++
 >++++
 >+++
 >+
 <<<<<<-
]
>++++++.
>++.
+++++++.
.
+++.
>>.
>-.
<<-.
<.
+++.
------.
--------.
>>>+.
>-.
=== END ===
== Categories ==
Category:Languages Category:Uncomputable Category:2024
PTL

PTL stands for the PoTtery Lottery, and has seven commands:
 M - install thousands of viruses on your computer
 N - do a random command in a random choice of one of these: BF, HQ9+
 A - installs adware on your computer
 B - deletes system32 and system64
 P - gives p*rn to innocent children and toddlers
 J - turns your computer into poisonous jelly
 C - freezes your blood and turns it blueish green
Any other character (except spaces, tabs, and newlines) run all the commands at once.
==Examples==
===Hello World===
This has a 8.33% (1 in 12) chance of working:
 N
===Cat===
This has a 1.67% (1 in 60) chance of working:
 NNNNN
===Truth machine===
This has a 0.29% (1 in 348) chance of working:
 NNNNNNNNNNNNNNNNNNNNNNNNNNNNN
Category:2023
PTSL

or Portable Terse Stack Language is a language designed by User:Moon for use in a simulated universe/tabletop game/community written world. It is intended as a mechanism for storing programs on cartridges designed to run on multiple systems. Due to its nature as a terse language, it's also rather esoteric, hence it being documented on this wiki.
__TOC__
== Execution enviornment ==
 executes in a flat memory space of up to 224 bytes (16MiB), divided in 8KB pages. Any memory beyond this space is treated as Memory Mapped IO space, for direct access to system devices when the program supports it. There can be up to 254 MMIO devices mapped, with MMIO device 0 being RAM and MMIO device 1 being the first 64KB of cartridge.
0 	RAM
1 	CART[0]
2 	MMIO[0]
3-254	MMIO[1-253]
255 	MMIO[254]
Program execution can begin in either RAM (Bank 0) or CART[0] (Bank 1), MMIO devices are not executable unless they are mapped as a storage device, like extra RAM or extra cartridge space.
Not all of RAM is immediately accessable, and has to be requested in 64KB pages by the program before use.
The stack is located in the first page of RAM, with values on the stack being exactly 32 bits.
== Instructions ==
Each opcode is 8 bits long, with up to 32 bits of data associated with it.
== Example code ==
The following is written in the human readable PTSLASM format, instead of PTSL directly.
=== Hello, World! ===
 ; Assumes that it is running on a MX08-A. Not a good example of portable code :)
 %DEF TERMINAL_DEVICE_ID 0xFF000001 ; MX08-A terminal
 %DEF MMIO0 0x02000000
 %DEF STR_HELLO_WORLD_LEN 13
 [ORG 0x000000]
 _START:
 PUSHI24 0x001000
 PUSHRSP ; Set up return stack. Not used in this demo, but worth setting up.
 PUSHI8 2
 PUSHI32 TERMINAL_DEVICE_ID
 MAPDEV
 PUSHI8 STR_HELLO_WORLD_LEN
 PUSHI24 STR_HELLO_WORLD
 PUSHI32 MMIO0
 COPY
 .HANG: JUMPRELI8 0x00
 
 STR_HELLO_WORLD: DB "Hello, World!"
Category:Languages Category:Low-level Category:Stack-based Category:Unimplemented
PUPPY

The language that only puppies can understand.
==Architecture==
The program memory is defined a single signed integer value, amenable to incrementing and decrementing, as well as output in character form.
==Syntax==
PUPPY is an esoteric programming language that is made up of lowercase and uppercase forms of BARK, WOOF and the spacebar.
One thing to note is that PUPPY only understands your code if it contains upper and lowercase forms of WOOF and BARK. If it contains something like WOO or BAARK, the puppy will tell you that he doesn't understand your code. However, your code can contain something like BA rK because the puppy removes the spaces between tokens before reading your code.
==Instructions==
After you have mastered the rule above, PUPPY is extremely easy to learn. Like in brainfuck, you start off with a value set at 0, but only one. To add 1 to the value, you should type an uppercase letter and to take 1, type a lowercase letter. Ensure that you're following the above rule. To output the ASCII representation of the value, you use space.
==Examples==
===Print a letter===
The following program prints the letter “H” to the standard output. Please note the trailing space character.
 BARKWOOFBARKWOOFBARKWOOFBARKWOOFBARKWOOFBARKWOOFBARKWOOFBARKWOOFBARKWOOF 
==Interpreter==
* Common Lisp implementation of the PUPPY programming language.
Category:Languages
Category:Joke languages
Category:Total
Category:Implemented
Category:Unusable for programming
Category:Output only
Category:Thematic
Category:Low-level
Category:2017
PUSH

PUSH is an esoteric programming language created by User:Expliked in November 2020. It is a stack-based language.
== Syntax ==
Keyword 	Meaning
PUSH: (integer); 	Pushes the given value to the stack.
ADD: (integer); 	Adds the given value to the last value of the stack.
SUBTRACT: (integer);	Subtracts the given value to the last value of the stack.
PULL; 	Outputs the first value from the stack, then removes it.
INPUT; 	Prompts for user input. Each individual character will be stored in the stack.
DO; 	Starts a do-while loop. A do-while loop cannot be created inside another do-while loop.
WHILE; 	The end of a do-while loop. If the last value of the stack is not 0, it will jump back to the DO; statement.
CLEAR; 	Clears the stack.
[ 	Denotes the start of a comment.
] 	Denotes the end of a comment.
== Code structure ==
In PUSH, spaces, newlines, carriage returns, and tabs are ignored.
All keywords must have a ; after them.
== Examples ==
Simple Hello, World! program:
 PUSH: 72;
 PUSH: 101;
 PUSH: 108;
 PUSH: 108;
 PUSH: 111;
 PUSH: 44;
 PUSH: 32;
 PUSH: 87;
 PUSH: 111;
 PUSH: 114;
 PUSH: 108;
 PUSH: 100;
 PUSH: 33;
 PUSH: 10;
 
 [Output all characters:]
 DO;
 PULL;
 WHILE;
== Breaking down "Hello, World!" ==
The PULL keyword will output the first value of the stack, then delete that value. It then shifts all values after it to the left.
After we are done pushing all of our values to the stack, this is what it will appear as:
 H e l l o , " " W o r l d ! \n
 72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 10
After the first PULL is used, the stack looks like this:
 e l l o , " " W o r l d ! \n
 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 10
If you repeat this process you will have eventually printed out all characters.
Instead of doing PULL after every PUSH, we can just use DO; PULL; WHILE;. This will output every character until there are no more left.
== More examples ==
Cat program (expects at least one character of input):
 INPUT;
 DO;
 PULL;
 WHILE;
99 Bottles of Beer:
 https://pastebin.com/TQVxJT9v
== External resources ==
* Interpreter written in C++.
Category:Languages Category:Usability unknown Category:Stack-based Category:Implemented Category:Push-down automata
PUSHEM

PUSHEM is macro assembler for the BytePusher machine. It works exclusively in hex. There are some primitives, and then you can also define macros for other uses.
==Tables==
PUSHEM works by creating tables to do calculations with. There are two kind of tables, small tables (256 bytes) and big tables (64K bytes).
Here is an example of creating a big table for adding numbers:
 \T __MAJOR #1 __MINOR
==Macros==
You can create macros which can expand into larger pieces of codes.
Here is an example to make a label name at the current point in the program:
 { Label (name)
 \c ^1 ?
 }
==Instructions==
An instruction can store a source address, destination address, and jump address. By default, the jump address is the address of the next instruction.
To make a move instruction:
 \x #0006C0 #00004F
To jump:
 \j +#000100
You can combine multiple moves for indirect moves and stuff:
 \x Counter x&Next
 \c Next ?
 \x Table1 Counter
==Examples==
* "Munching Squares" program
==External resources==
* http://zzo38computer.org/prog/BytePusher/
PYSP

PYSP (for PYthon String Programming) is a DSL embedded by an unknown user (who later was revealed to be User:RocketRace) in Python, described as 'lisplike'. It seems to have been inspired by such languages as Parenthesis Hell.
== Syntax ==
PYSP has two syntax modes. When USE_SAFE_SENTINEL mode is set, Ø represents nil and ( and ) are for function calls. When unset, ... is used for nil instead. Numbers are constructed by repeatedly calling nil with no arguments. ...() is 0, ...()() is 1, ...()()() 2, etc. Lists are constructed by calling nil repeatedly with one argument. ...(...) is [], ...(...)(a) is [a], ...(...)(a)(b) is [a, b], etc.
== Semantics ==
Integers can only be zero or above. Calling such an integer allows indexing on a global tree-like data structure that stores predefined functions. 0 is the so called 'root', and 1 is the 'trunk'. Any higher numbers seem to be left for programmer use. 0 contains a tree of basic operations, accessed by calling 0 with a list of indices representing where in the tree the required function is. For example, calling 0 with a list [1, 5, etc seems to call the modulo function with the rest of the list, according to the specification (although the reference implementation instead defines it as exponentiation).
== Origins ==
PYSP was first published in an anonymous entry in the inaugural Esoserver code guessing contest (continued from on the Esolangs Discord server). The contest revolves around making it difficult for participants to guess who wrote the code for your submission, so naturally the specification was just as unsigned as its integers.
Category:LanguagesCategory:2021Category:ImplementedCategory:LanguagesCategory:Unknown computational class
Pada

Pada is the Croatian word for falling, according to Google Translate. Pada was created by User:revcompgeek on July 27, 2009.
== Overview ==
The main construct that Pada uses is a 3 level switch design something like this:
 /
 / /
 / / / /
 0 0 0 0 0 0 0 0
Each of the "/" characters corresponds to a switch that can point either to the left or the right (and initially points to the left). Commands start at the top switch and fall down to the switch on the side of the one they land on until they are executed. Each of the "0" characters is a bit that corresponds to a bit stack.
== Commands ==
=== Switch Manipulation ===
The "." command will flip the direction of the switch it lands on. In order to manipulate the lower levels of switches, the "O" and "o" commands are used. The "o" command moves in the direction of the switch it lands on and then becomes a ".". The "O" command does the same thing but become a "o" instead. "Q" and "q" are the same but they flip the switch they touch before falling down to the lower level.
Example:
 o 
 / . / / 
 / / / / \ / 
 / / / / / / / / / / / / 
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 O - Become o
 o - Become .
 . - Flip switch landed on
 Q - Flip and become q
 q - Flip and become .
=== Bit Manipulation ===
All of these commands operate on the bit that they eventually fall on.
 1 - Set the bit to 1
 0 - Set the bit to 0
 ~ - Flip the bit
 v - Push the bit onto its bit stack
 ^ - Pop the bit from its bit stack
=== IO ===
These read/write the byte starting from the bit it lands on, wrapping around
 w - Sends the byte to stdout
 r - Reads one byte from stdin
=== Control flow ===
 # - prevent bit from changing until it gets another # (popping throws away one bit from the top of the stack)
 ? - if bit is true skip the next command
 * - jump: read a signed byte like w and jump in that direction
== Examples ==
===Hello, World!===
 O~.~.OwoO~Q~.OwoO~.O~qwwo~O~owO~o~O~oOw.~O~.w~.~O~Q~OwQ~.~O~wQ~q~OwO~.O~qwQ~.wO~oOw~O~Qw
 ~.O~Ow~q~Owo~O~Oww~Q~qwo~q~O~wQ~q~w~q~q~Q~Ow~Q~Q~wo~q~w.~q~w.~.wO~qw
== External resources ==
* Interpreter in Ruby by Martin Ender
Page fault

A page fault is an event which occurs during managed computation when a requested region of memory, known as a page, is not available. Traditionally, the computation is paused while the requested page is made available, or halted if the page cannot be made available. Page faults are usually raised by hardware memory management units (MMUs) in response to attempts to deference pointers.
== trapcc ==
The x86 MMU can be programmed as a wikipedia:weird machine via an encoding of subleq onto a predefined memory layout along with custom fault handlers. When the MMU faults, it immediately experiences a wikipedia:double fault and alters memory while recovering; repeated page faults cause computation without executing non-fault-handler code.
== Related links ==
* trapcc
* Mov
* wikipedia:page fault
Category:Concepts
PaidFuck

PaidFuck is a joke brainfuck derivative invented by User:None1 and inspired by EA Script, It's in the code.. It is almost the same, except you have to pay to use it.
==Cost==
Writing a program is free, but executing a program of length l once costs $2l×kk. Where k is the number of microseconds that have passed since 2024/1/1 0:00:00.000000. (1 microsecond=0.000001 seconds).
==Examples==
===Cat program===
 ,[.,]
It costs $32×kk to run. The number is short, but remember how large kk is!
===Hello, World!===
 +[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.
This is the cheapest PaidFuck program, but it costs $4722366482869645213696×kk to run!
Category:Languages Category:2024 Category:Joke languages Category:Brainfuck derivatives Category:Usability not set Category:No set computational class
PainLang

==Overview==
PainLang is basically Brainf*** but written in Python and writes Lua and has one less core command (7 excluding comments and debug).
It was written by User:TeamLightning due to boredom.
==Computational class==
Because PainLang has 4+1+8\times16=133 bits of memory by default (4 for the index, 1 for the negation bit, and 8 bits for each of the 16 cells), it is a bounded-storage machine.
==Syntax==
Given an index i, a negation bit neg, and a sixteen cell tape t, with each cell being one byte: 
 o sets i to (i + 1) % len(t)
 w increments t[i], and wraps to zero upon exceeding one byte 
 ! prints the ascii character t[i] represents 
 ? reads the ascii value of one byte from the console into t[i]
 O jumps to the matching W character if t[i] is zero 
 W jumps to the matching O character if t[i] is nonzero 
 a sets neg to neg * -1 
 A is a comment 
 If debug mode is enabled, # prints debug info
Loops are not nestable in the legacy Python compiler.
==Examples==
===Hello World!===
 wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
 owwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
 owwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
 owwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
 owwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
 owwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
 owwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
 owwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
 aoooooooa
 !o!o!!o!o!o!aoo!aooo!aoooo!aooooo!
This specific version of Hello World was written before loops were implemented.
Output: Hello World
===Number to ASCII character===
 o?o?o?aoooa#
 wwwwwwwwOoawwwwwwowaW
 wwwwwwwwOooawwwwwwoowaW
 wwwwwwwwOoooawwwwwwooowaW
 oOaoawwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwoawaW#oOaooawwwwwwwwwwooawaW#oOaoooawoooawaW#
 aoooa!
Input: 3 digit number, left padded with zeroes.
Output: ASCII character input represents.
==Interpreters==
The current interpreter and compiler source can be found here.
The legacy Python interpreter and compiler source can be found here.
Category:Cell-based Category:2021 Category:Bounded-storage machine Category:Brainfuck_derivatives Category:Implemented Category:Low-level Category:Languages
Painfuck

Painfuck is an brainfuck derivative that has the mix of painful syntax and painful way to write. It gets hella obvious when shown below:
==Commands==
...
 Commands
Text	Function
p 	Add two to the selected value on tape
s 	Subtract one from the selected value on tape
r 	Go right two times on tape
l 	Go left on tape
i 	Get input and store as a number
j 	Get input and store as an ASCII value
o 	Output as number
u 	Output as character
a 	Go to the matching b if value on tape is zero
b 	Go back to the matching a if value on tape is not zero
k 	Square selected value on tape
z 	Zero selected value on tape
h 	Half the selected value on tape
w 	Clone the value to the right of selected
q 	Clone the value to the left of selected
c 	Do the next command 7 times
y 	Do the next command only half the time
e 	End program when reached
v 	Do next command if value on tape is zero
d 	Go back to the start of tape
t 	Do the last command 3 times
Then. After a command is executed, encrypt the ENTIRE rest of the code with this encryption scheme:
 BEFORE: pysrlijouavbtkzhwqdec
 AFTER : euopdhzbclkqsjwariyvt
This makes:
 pso
Become:
 ptt
And in order to run pso, you have to use that.
Or as another example,
 ptptsso
Has to run like this:
 pcwyydd
Looks nothing like the original, almost.
==Examples==
Remember, this chart will be used throughout:
 BEFORE: pysrlijouavbtkzhwqdec
 AFTER : euopdhzbclkqsjwariyvt
===Cat program===
Without decryption:
 jaujb
With encryption (required to run):
 jhdec
===Looping counter===
 pticjdy
===Hello, world!===
NOTE: The program doesn't include newlines!!!!
 crwydvoeprqddkveuwbldtveprsyjulephwzjtvsprwahkaeouztjkuypriihi
 bbcrtyjklaswwzjlleprqjldteprwzyyuyhrazoqoosyyuyhoppiozjtveprwi
==Implementations==
A C++ interpreter by User:Bangyen.
Category:LanguagesCategory:Joke languages Category:Brainfuck derivatives Category:Turing complete Category:Unusable for programming Category:Turing tarpits Category: Implemented
Paint

Paint is some sort of esoteric language made by User:EvyLah. I have absolutely no idea how to describe this better.
== Overview ==
Paint contains 2 brainfuck-like tapes (which will be called tape 0 and 1) which both do the same thing. Along with a standard text output, Paint has a 16x16 pixel canvas, where each pixel can be either on or off.
== Commands ==
=== Universal ===
Opcode	Description
0 1 	Select either tape 0 or 1 to modify. Anything referencing manipulating a cell means manipulating the cell on the selected tape.
=== Tape manipulation ===
Opcode 	Description
+ - > <	Same as brainfuck.
' 	Toggles any cell bounds, so cells can be any positive and negative integer. Once turned back on, all cells will be set to its value mod 256.
=== Control flow ===
Opcode	Description
{ } 	Skip the code inside if the current cell is zero, otherwise do nothing. } does nothing other than act as a point to jump to.
[ ] 	Same as brainfuck.
=== I/O ===
Opcode	Description
, ; 	Take input as one character or one number in that order, and store it in the current cell. Input will be taken mod 256 if cell bounds are on. Users can input negative numbers if cell bounds are off, and decimals will be rounded.
. : 	Print the current cell as a Unicode character or number, in that order.
=== Canvas commands ===
Opcode	Description
` 	Take the current cell on the currently selected tape as y, and the other tape as x. Then turn on the pixel at (x, y). (0, 0) marks the top left corner.
~ 	Same as ` command, but instead turns off the pixel.
c 	Clears canvas (sets every pixel to off).
f 	Fills canvas (sets every pixel to on).
Every other character is ignored.
== Examples ==
All programs compatible with brainfuck work in Paint as well.
=== Hello, World! ===
Taken from Brainfuck+2, although any Hello, World! program will work.
 >++++++++[>+++++++++>++++++++++++>+++++++++++++>++++++++++++++>++++++
 >++++>+++++++++++>++++++++++++++[<]>-]>.>+++++.>++++..>-.>----.>.>-.<
 <<.+++.<.<-.>>>>+.
=== A+B Problem ===
The A+B Problem requires a program takes 2 numbers as input and outputs their sum.
 ';>;[<+>-]<:
== Implementations ==
The way you make the canvas is up to you, but I would use ASCII art, with an on pixel being # (but doesn't have to be) and and off being a space. It's also your choice if you have the canvas repeatedly update itself, or show it once every cycle, or just once at the end.
(When I make my implementation) I would add the text output to a variable and then show it along with the canvas at the end.
Category:Languages Category:2024 Category:Cell-based Category:Brainfuck derivatives