nyuuzyou/wikis huggingface dataset:
PhD

PhD (Push halt Down automaton) is a PDA with a PDA-halting oracle.
== Overview ==
There is exactly one stack of bits. The stack is initially filled with infinitely many 0 bits.
Source code consists of instructions (all other characters are ignored). Instructions are:
* 0 - push bit 0 to the stack
* ~ - invert the top bit of the stack
* * - pop a bit, if the bit is 1, then pop another bit and output it, otherwise push the next input bit
* [...] - pop a bit from the stack and if the bit is 1 then execute ... and then execute [...] again (note: ... stands for anything)
* (...) - if ... would halt when ran on the current stack, then push 0, otherwise do nothing (note: ... cannot contain characters (, ), or *), any changes made to the stack inside ... will be reverted after executing (...)
== I/O format ==
Input is a bit array. Before program starts, each input bit is prefixed by 1 and infinitely many zeros are appended. For example, input string 1011 becomes:
 111011110000000000000...
Output remains unchanged.
== Examples ==
=== Cat program ===
 *[0*0~*0*]
Try it online
=== Truth-machine ===
 *0*[0~0~*0~]~0~*
Try it online
=== Hello, World! ===
 00~*00~*00~*0~0~*00~*00~*0~0~*00~*0~0~*00~*0~0~*00~*00~*0~0~*0~0~*00~*00~*00~*0~0~*0~0~*00~*0~0~*0~0
 ~*00~*00~*00~*0~0~*0~0~*00~*0~0~*0~0~*00~*0~0~*0~0~*0~0~*0~0~*00~*0~0~*0~0~*00~*00~*00~*0~0~*0~0~*00
 ~*0~0~*00~*00~*00~*00~*00~*00~*00~*0~0~*00~*00~*0~0~*0~0~*0~0~*00~*0~0~*00~*0~0~*00~*0~0~*0~0~*0~0~*
 0~0~*00~*0~0~*0~0~*00~*00~*0~0~*00~*00~*0~0~*0~0~*0~0~*00~*00~*00~*0~0~*0~0~*00~*0~0~*0~0~*00~*00~*0
 0~*0~0~*00~*00~*0~0~*0~0~*00~*0~0~*00~*00~*00~*00~*0~0~*
Try it online
=== If-then-else ===
If the input is 0, then output 1011, and if the input is 1 output 001
 *0*[[0]00~*00~*0~0~*00][0~0~*00~*0~0~*0~0~*0]
Try it online
== Computational class ==
Unknown.
== Interpreters ==
Interpreter
Category:Languages
Category:Unknown computational class
Category:2021
Category:Implemented
Philosophy Script

Philosophy Script is a language based on philosophy. It is saved as .PhS (from PhD).
==Language==
===General===
Comments: @
 @This is a comment
Variables: Why... ?
 Why x=1?
Printing text to the screen:
 presocratic.Anaximines[This is text]
 presocratic.Anaximines[This is X: ]&x
Methods:
 socraticMethod()[...]
 socraticMethod(x)[
 commands
 ]
If...else:
 If () moral [...] debate [...]
 If (x=1) moral [
 commands
 ]
 debate [
 commands
 ]
Classes:
 presocratic.Thales[...]
 presocratic.Thales [
 stuff
 ]
===Objects:===
Object base:
 socratic.Socrates(
Object types:
SocratesHandles.
*Button
*CheckMenu
*CheckBox
*RadioMenu
*Radio
*PopupMenu
*PopupMenuItem
PlatoHandles.
*Textfeild
)[
commands
]
 socratic.Socrates (SocratesHandles.CheckMenu) [
 socratic.Socrates (SocratesHandles.CheckBox) [
 Why x=2?
 ]
 socratic.Socrates (SocraticHandles.CheckBox) [
 Why y=2?
 ]
 ]
==Commands==
Command 	Description 	Example
Aquinas 	Shows a computers factory setting data. 	
 Aquinas <someip>
Aristotle 	Sets a computer's ip a name. 	
 Aristotle <someip>=Joe's Computer
Can we know anything? 	Deletes a file. 	
 Can we know anything? <someip> <filename>
Descartes 	Changes the current directory. 	
 Descartes <someip> <directory>
Epistemology 	Opens connection to the web. 	
 Epistemology
Epitectus 	Moves a file from one ip to another. 	
 Epitectus <someip>-<someip> <filename>
Ethics 	Print the file's status information. 	
 Ethics
Hegel 	Sweeps a disk for viruses. 	
 Hegel in <someip> with <someSecuritySystem>
If a tree falls... 	Opens internet explorer to a specific page. 	
 If a tree falls... <someip> to <url>
Is happiness possible? 	Converts a .NA file into a .PhS file 	
 Is happiness possible? <filename.NA> SaveAs <filename.PhS
Is philosophy practical? 	Copies a file from one ip to another. 	
 Is philosophy practical? <filename> <someip>-<someip>
Is there a god? 	Exits the file. 	
 Is there a god?
Is there objectivity to Ethics?	Deletes a drive. 	
 Is there objectivity to Ethics? <someip> <drive>
Kant 	Opens itself. 	
 Kant in <someip>
Kierkegaard 	Prints the current .PhS file script. 	
 Kierkegaard in <someip>
Metaphysics 	Reverts to a .NA file. 	
 Metaphysics <filename.NA>
Occam 	Calls one philosophy file script from another. 	
 Occam Network10.PhS from <someip>
Philosophy 	Closes connection to the web. 	
 Philosophy
What is the good life? 	Finds an ip 	
 What is the good life? <someip>
Who Am I? 	Lists the contents of a drive. 	
 Who am I? <someip> <drive>
Why is there suffering? 	Deletes all files in the computer, 	
 Why is there suffering? <someip>
Wisdom 	Displays the internet connections operating control parameters.	
 Wisdom
Category:Languages
Category:Thematic
Category:Unimplemented
Category:Pseudonatural
Category:2009
Phone call

Phone call is a minimalist programming language created by User:A that uses the character set possible to enter in a phone call.
These characters are enterable (please click to navigate to the respective command):
1	2	3
4	5	6
7	8	9
*	0	#
==Commands==
Command	Description
0 	Pushes 0 unto the stack.
1 	Pushes -1 unto the stack.
2 	Pushes 2 unto the stack.
3 	Pushes 3 unto the stack.
4 	Pushes 5 unto the stack.
5 	Pushes 7 unto the stack.
6 	Pushes 11 unto the stack.
7 	Pushes 13 unto the stack.
8 	Pops the stack.
9 	Copies the top of the stack to the accumulator.
* 	Pops the two top stack elements, multiplies them, and pushes their product unto the stack.
# 	Detects the value of the accumulator:
* If the accumulator value acc is even, jumps to the character at the one-based code position p that satisfies: p = acc / 2 + 1.
* If the accumulator value is odd, repeats the subsequent instructions until the top of the stack equals 0.
==Examples==
===Powers of Two===
This program infinitely generates at the stack's top the powers of two, jumping in the code by mediation of the accumulator.
 22*298#
===Loop===
This program pushes the elements 0, 3, 5, 7, 11 and 13 unto the stack, and repeated pops from the stack until the value 0 reappears at the top.
 0345679#8
==Interpreter==
* Common Lisp implementation of the Phone call programming language.
Category:Languages
Category:2019
Category:Stack-based
Category:Implemented
Phoneboard

Phoneboard is an esolang which use just the 12 keys on a phone [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, #, *]. It uses two stacks to store data.
==Commands==
The language offers twelve commands, each one corresponding to a phone key. Operations consume the data they use.
Name	Function
0 	Subtract the top elements of the stack (The top goes on the left)
1 	Push 1
2 	Push 2
3 	Add the top elements of the stack
4 	Swap what stack is being used to store data
5 	Take input and push its Unicode code point to the top
6 	ROTCCW
7 	Swap the top 2 elements
8 	Duplicate the top element
9 	Output the top as a Unicode character
# 	While the top 2 elements are equal
* 	End While
==Examples==
===Cat program===
An infinitely repeating cat program follows:
 11#5911*
===Truth-machine===
The following program provides a truth-machine:
 22322332233223322332233223322332233223322332233120388589#9888*
==Interpreter==
* Common Lisp implementation of the Phoneboard programming language.
Category: Languages
Category: 2022
Category: Stack-based
Category: Implemented
Photon

:You may be looking for the other language named Photon (by Quintopia).
Photon is an esolang where each command has the same structure.
They take the form of two arguments passed to a function.
===Intro===
Arguments are made of 2 characters: a symbol and a digit.
If the symbol is a #, the digit is interpreted as a literal value, ie. #9 would evaluate to 9.
If it is a :, the digit is interpreted as a variable, ie. :9 would give the value of the variable 9.
There are two special values:
:- is a null value, used for functions taking fewer than two arguments.
:$ is the result of the last function returning a value.
Functions are always 1 character, never a letter or number.
All lines have the following format:
[arg1,arg2>func]
This format must be kept EXACTLY. Any lines not following it will not run, and can be used for comments.
No spaces are allowed.
Because of this, in an ideal Photon program, there will be no letters.
===Command List===
Character	Command
+ 	Add the two arguments.
- 	Subtract the two arguments, replacing negatives with 0.
* 	Multiply the two arguments.
/ 	Divide and floor the two arguments.
_ 	Print the numerical value of the first argument. Ignore the second.
. 	Reset the variables. All user defined variables are deleted, and :$ is set to 0.
@ 	Print the ASCII value of the first argument.
~ 	Print a newline.
= 	Set the variable named the first argument to the second.
? 	Set the variable of the first argument to the ASCII value of an input character if it is not a digit, to it if it is.
^ 	Go to the line of the first argument. (0 = first line)
{ 	If the first argument is not 0, go to the line of the second argument.
===Examples===
Hello World
 [#9,#0>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#2,:$>+]
 [#7,:$>+]
 [:$,:->@]
 [:$,#3>-]
 [:$,:->@]
 [#7,:$>+]
 [:$,:->@]
 [:$,:->@]
 [#3,:$>+]
 [:$,:->@]
 [:$,:$>-]
 [#8,:$>+]
 [#8,:$>+]
 [#8,:$>+]
 [#8,:$>+]
 [:$,:->@]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#1,:$>+]
 [:$,:->@]
 [:$,#8>-]
 [:$,:->@]
 [#3,:$>+]
 [:$,:->@]
 [:$,#6>-]
 [:$,:->@]
 [:$,#8>-]
 [:$,:->@]
 [:-,:->~]
99 Bottles
 [:1,#0>=]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [#9,:$>+]
 [:1,:$>=]
 [:2,#0>=]
 [#8,#8>+]
 [:2,:$>=]
 [:1,:->_]
 [:3,#0>=]
 [#8,#4>*]
 [:3,:$>=]
 [:3,:->@]
 [:3,:3>+]
 [:$,#2>+]
 [:3,:$>=]
 [:3,:->@]
 [#9,:3>+]
 [#4,:$>+]
 [:3,:$>=]
 [:3,:->@]
 [#5,:$>+]
 [:3,:$>=]
 [:3,:->@]
 [:3,:$>=]
 [:3,:->@]
 [:$,#8>-]
 [:3,:$>=]
 [:3,:->@]
 [:$,#7>-]
 [:3,:$>=]
 [:3,:->@]
 [:$,#9>+]
 [:$,#5>+]
 [:3,:$>=]
 [:3,:->@]
 [#8,#4>*]
 [:3,:$>=]
 [:3,:->@]
 [:3,:3>+]
 [:$,#1>+]
 [:$,#9>+]
 [:$,#5>+]
 [:3,:$>=]
 [:3,:->@]
 [:$,#9>-]
 [:3,:$>=]
 [:3,:->@]
 [#8,#4>*]
 [:3,:$>=]
 [:3,:->@]
 [:3,:3>+]
 [:$,#2>+]
 [:3,:$>=]
 [:3,:->@]
 [:$,#3>+]
 [:3,:$>=]
 [:3,:->@]
 [:3,:->@]
 [:$,#9>+]
 [:$,#4>+]
 [:3,:$>=]
 [:3,:->@]
 [:-,:->~]
 [:1,#1>-]
 [:1,:$>=]
 [:1,:2>{]
Take and Square User Input
 [:1,#0>=]
 [:1,:->?]
 [:1,:1>*]
 [:1,:$>=]
 [:1,:->_]
 [:-,:->~]
 [:-,:->.]
More examples are included in the source here.
Category:Languages
Category:2019
Category:Low-level
Pi(e)

Pi(e) is an esoteric programming language based on the product of the formula, pi(e) or pi times e.
== Specifics ==
It just prints the digits of pi multiplied by e.
== Interpreters ==
A very stupid interpreter by User:None1, in Python:
from math import *;
print(pi*e)
Category:Languages
Category:Joke languages
Category:No-code esolang
Category:Implemented
Pi-alpha function

The pi-alpha function is a function that accepts an input and outputs terms that are ratios betwen factorials of primes.
==Pi-alpha function==
The following is the definition of the pi-alpha function. p_{n} is the nth prime number.
\pi_{\alpha}(n)=\sum_{k=2}^{n+1}{\frac{p_{k-1}!}{p_{k}!}} \{n\in\mathbb{N}\}
The following are the values returned by pi-alpha function for the first 5 inputs.
\pi_{\alpha}(1)=\frac{2!}{3!}=0.\overline{3}
\pi_{\alpha}(2)=\frac{2!}{3!}+\frac{3!}{5!}=0.38\overline{3}
\pi_{\alpha}(3)=\frac{2!}{3!}+\frac{3!}{5!}+\frac{5!}{7!}=0.40\overline{714285}
\pi_{\alpha}(4)=\frac{2!}{3!}+\frac{3!}{5!}+\frac{5!}{7!}+\frac{7!}{11!}=0.4072\overline{691197}
\pi_{\alpha}(5)=\frac{2!}{3!}+\frac{3!}{5!}+\frac{5!}{7!}+\frac{7!}{11!}+\frac{11!}{13!}=0.4136\overline{793761}
The countably infinite set of values returned by the pi-alpha function is known as the set of pi-alpha numbers. The largest pi-alpha number with a known value is \pi_{\alpha}(3000), equal to 0.4192216766963055...
==Pi-alpha constant==
The pi-alpha constant is an irrational number equal to \pi_{\alpha}(\infty), or it can be stated that \pi_{\alpha}(n) computes the first n terms of the pi-alpha constant. However, it is currently uncertain if, as n goes to infinity, if \pi_{\alpha}(n) converges to some real number or diverges to infinity.
The largest pi-alpha number with a known value, \pi_{\alpha}(3000), and the two thousand previous pi-alpha numbers, imply that \pi_{\alpha}=0.41922.... This estimate assumes the pi-alpha constant is finite and less than 0.5.
==Implementations==
===Python===
The following Python script defines pialpha(n).
def pialpha(n):
 import math
 number = 0
 primes = [2]
 num = 3
 while len(primes) <= n:
 if all(num%i!=0 for i in range(2,int(math.sqrt(num))+1)): # Finds prime numbers
 primes.append(num)
 num += 1
 for i in range(1, n+1): # Calculates the sum
 number += math.factorial(primes[i-1]) / math.factorial(primes[i])
 return number
Languages that cannot compute the pi-alpha function are likely not suitable for practical use.
===MoreMathRPN===
This was a very good puzzle! The hardest task here is calculating A40(n)
 inputR
 floor
 hold input
 del 0
 2
 3
 5
 0
 repeat $input
 1
 repeat ]4
 >>> 0
 *
 next
 repeat ]3
 >>> 0
 /
 next
 +
 >>> 0
 1
 +
 -> 2
 repeat ]1
 >> 0
 >> 2
 5
 +
 >>> 0
 -
 >> ]0
 del 1
 %
 step
 2
 *
 jmp ]0
 leap 8
 del 0
 next
 "Prime!
 del 1
 >> 0
 <- 2
 2
 +
 <- 1
 jmp 5
 del 0
 2
 +
 jmp -27
 next
 outputV
Category:Concepts
Category:Program forms
Pico Scheme

Pico Scheme is a minimalist purely functional version of Scheme, with all non-functional features removed. The syntax and semantics are defined both informally and in formal extended BNF and denotational semantics.
== Abstract Syntax ==
* K ∈ Con: constants, including quotations
* I ∈ Ide: identifiers (variables)
* E ∈ Exp: expressions
* ∆ ∈ Dec: declarations
Exp → K | I | (E0 E*)
| (lambda (I*) ∆* E0)
| (lambda I ∆* E0)
| (if E0 E1 E2) | (if E0 E1 )
Dec → (define I E0 )
==Examples==
===Hello, World!===
 (display '(Hello World!))
 (newline)
Output:
 (Hello World!)
=== Y combinator and Factorial ===
 (let ((Y (lambda (phi)
 ((lambda (f) (f f))
 (lambda (f)
 (phi (lambda x (apply (f f) x))))))))
 (let ((fact
 (Y (lambda (fact)
 (lambda (n)
 	 	 (if (< n 2) 1
 (* n (fact (- n 1)))))))))
 (fact 5)))
==External resources==
* Pico version of revised⁷ report on the algorithmic language scheme specification releases
Category:Languages 
Category:Turing complete
Category:Output only
Category:Implemented
Category:Functional paradigm
Category:2021
Picofuck

Picofuck (PF) is the set of 2 command, simple translations of Reversible Bitfuck (RBF). It is not currently known if any PF languages exist. However, it is known that 3 command, simple translations of RBF exist (see Nanofuck). See the talk page for current action.
==Picofuck project==
The Picofuck project is a community driven effort to discover or disprove the existence of PF languages. It was initiated by User:Orby in March of 2017. The main objectives of the project are (in order of priority)
# Prove or disprove the existence of PF languages.
# If PF languages are found to exist, discover an example.
# Determine the minimum length of a PF language and enumerate all PF languages of that length.
# Write an interpreter for a PF language.
# Write a program that will take a PF program and produce its inverse.
==PF languages==
No PF languages have been discovered at this time. When they are discovered, or proven not to exist, constructive examples or proof of non-existence will be provided here. PF languages will be titled PF0, PF1, etc. in the order in which they are discovered. See the talk page for candidate languages.
==Length of a PF language==
The length of a PF language is defined as the sum of the number of commands in RBF to which each PF command translates. For example, if the PF command [ translates to the 3 RBF commands *(> and the PF command ] translates to the 4 RBF commands )*(>) then the length of the PF language is 3 + 4 = 7.
==See also==
* Reversible Bitfuck
* Reversible Brainfuck
* Nanofuck
* Simple translation
Category: Languages
Category: Brainfuck derivatives
Category: Turing complete
Category: Reversible computing
Category: 2017
Pie

Pie is an 2-dimensional esoteric programming language created by User:InfiniteDonuts that is sort of a Befunge/PATH hybrid.
Like Befunge, it has strings and uses a stack for memory operations, and both arrows (like Befunge) and mirrors (like PATH and SNUSP) can be used for program flow. It currently has no interpreter.
==Instructions==
Instruction	What it does
/ or \ 	Mirrors
< > ^ v 	Go left, right, up, or down, respectively
! 	Skip the next instruction
? 	If the number on top of the stack is 0, skip the next instruction.
+ 	Pop two values, then push their sum onto the stack.
- 	Pop two values, then push their difference onto the stack.
* 	Pop two values, then push their product onto the stack.
/ 	Pop two values, then push their quotient onto the stack.
" 	Toggle string mode.
# 	Print the top item of the stack as a number and pop it.
& 	Get input and push it onto the stack.
Any number 	Push it onto the stack.
==Computational class==
As Pie can only access the top of the stack, it is a push-down automaton.
Category:Languages
Category:Unimplemented
Category:Push-down automata
Category:2019
Category:Two-dimensional languages
Category:Stack-based
Pig

Pig is a programming language that has only one keyword: the word PIG.
==Usage==
Pig can be used to create text files. To code in Pig, write the title of your text file, then write PIG, then write the contents of the text file.
==Various Programs in Pig==
===Hello, World!===
The following code creates a text file named "Hello, World!" which contents are "Hello, World!".
 Hello, World!PIGHello, World!
===Cat program===
Pig cannot create the Cat program because it is output only.
===Quine===
Pig cannot create a Quine either.
==The Pig series==
The Pig series is a a series of programming languages that are all based on Pig.
The languages are Pig, SickPig, DeadPig, QuinePig and DeafPig.
==Interpreter==
Simple interpreter written in C#.
 using System;
 using System.IO;
 
 class Pig
 {
 static int Main(string[] args)
 {
 try
 {
 if (args.Length < 1)
 {
 Console.WriteLine("USAGE: {0} <file>", Environment.GetCommandLineArgs()[0]);
 return 1;
 }
 string[] input = File.ReadAllText(args[0]).Split(new string[] { "PIG" }, 2, StringSplitOptions.None);
 if (input.Length < 2)
 {
 Console.WriteLine("File must contain the string 'PIG'.");
 return 2;
 }
 File.WriteAllText(input[0], input[1]);
 return 0;
 }
 catch (IOException ex)
 {
 Console.WriteLine(ex.Message);
 return 3;
 }
 }
 }
Simple Interpreter written in Python:
 def run_pig(code):
 assert type(code) is str, 'ERROR: Code must be a string.'
 assert 'PIG' in code, 'ERROR: Code must contain "PIG".'
 file_name, file_text = code.split('PIG', 1)
 file = open(f'{file_name}.txt', 'w')
 file.write(file_text)
 file.close()
==See also==
* DeadPig
* SickPig
* QuinePig
* DeafPig
* ExtendedPig
Category:Joke languages
Category:2015
Category:Implemented
Category:Output only
Category:Total
Category:Unusable for programming
Category:Languages
Pikalang

Pikalang is a joke esoteric programming language created by Blake Grotewold. It is identical to Brainfuck, except that the instructions are changed into the sounds made by Pikachu from Pokémon. It is one of the many trivial Brainfuck command substitutions. As such, it is a member of the TrivialBrainfuckSubstitution family of programming languages.
==Commands==
Brainfuck	Pikalang 	Description
> 	pipi 	Move the pointer to the right
< 	pichu 	Move the pointer to the left
pi 	Increment the memory cell under the pointer	
ka 	Decrement the memory cell under the pointer	
. 	pikachu 	Output the character signified by the cell at the pointer
, 	pikapi 	Input a character and store it in the cell at the pointer
[ 	pika 	Jump past the matching chu if the cell under the pointer is 0
] 	chu 	Jump back to the matching pika
==Hello, world! program==
 pi pi pi pi pi pi pi pi pi pi pika pipi pi pi pi pi pi pi pi pipi pi pi
 pi pi pi pi pi pi pi pi pipi pi pi pi pipi pi pichu pichu pichu pichu ka
 chu pipi pi pi pikachu pipi pi pikachu pi pi pi pi pi pi pi pikachu
 pikachu pi pi pi pikachu pipi pi pi pikachu pichu pichu pi pi pi pi pi
 pi pi pi pi pi pi pi pi pi pi pikachu pipi pikachu pi pi pi pikachu ka
 ka ka ka ka ka pikachu ka ka ka ka ka ka ka ka pikachu pipi pi pikachu
 pipi pikachu
==External resources==
* Github Repository
Category:Brainfuck equivalents
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2014
Category: Languages
Piko

== Piko ==
Piko is an esoteric language made by User:Kirbyiseatinghumanmeat. The idea of Piko is a canvas that allows you to draw things on it using commands!
== Overview ==
Piko is based on a canvas, an 8x8, 2D array. Every single string inside the canvas is called cells, you put a character (like /) to every single string on the canvas though commands, so that character will be represented on the current row and column in the canvas, when Piko finished your masterpiece, it will show it to the user.
== Commands ==
 | <n> Move horizontally (Go to the <n> row)
 - <n> Move vertically (Go to the <n> column)
 > <char> Replace the string at the current row and column with <char>
 _ <char> Fill the current row with <char>
 . <t> Sleep for <t> seconds (Kinda useless)
 ^ <filename> Run the filename
Note that the ^ command hasn't been tested on the original interpreter yet!
== Implementations ==
=== The original interpreter (Written in Ruby) ===
To use the interpreter, you will need to run it with a file name (like Arsel).
 class String
 def raw
 gsub("\\" * 2) { "\\" * 3 }
 end
 end
 class Piko
 def init_board
 result = *8
 for index in 0..result.length
 result[index] = [" "]*8
 end
 return result
 end
 def initialize(file)
 @script = file.split("\n")
 @board = init_board
 @valid_cmds = %w[
 | - > _ . ^
 ]
 @col, @row = 0, 0
 @pos = 0
 end
 def print_board()
 for smaller_board in @board
 puts smaller_board.to_s
 end
 end
 def run()
 while @pos < @script.length
 cmd, value = @script[@pos].split(" ")
 if @valid_cmds.include? cmd
 if cmd == "|"
 @row = value.to_i
 @pos += 1
 elsif cmd == "-"
 @col = value.to_i
 @pos += 1
 elsif cmd == ">"
 @board[@row][@col] = value.raw
 @pos += 1
 elsif cmd == "_"
 @board[@row] = [value]*8
 @pos += 1
 elsif cmd == "."
 sleep value.to_i
 @pos += 1
 elsif cmd == "^"
 run File.read(value)
 @pos += 1
 end
 elsif cmd == " " then @pos += 1
 else
 puts "Invalid command: #{cmd}"
 break
 end
 end
 print_board
 end
 end
 piko = Piko.new(File.read(ARGV[0]))
 piko.run
Pikobrain

Pikobrain is an operative system created by User:Hanzlu I guess you could call it esoteric.
Files are accessed by numbers. In the calculator numbers are written backwards. And there is a brainfuck compiler.
Currently only tested in VirtualBox.
== Project ==
May be that this project his abandoned, his creator didn't update this page and the source code for more than 2 months (2020 May).
The project repository (source code) is here
The project is not abandoned. Today I uploaded version 0.5 of the OS, making it a bit better than before.
==See also==
* Esoteric Operating System
* List_of_ideas#Ideas_related_to_esoteric_operating_systems, esoteric processors and esoteric computers
Category:Implemented
Pile.js

pile.js is a combination of an esoteric library for JavaScript (aka ECMAScript) and a coding style that requires you to use a rather strange data model for all operations- the stack. However, everything is still Javascript, so you can't use postfix as one normally would, making everything 1,000,000% more confusing for JavaScript programmers and concatenative programmers alike.
== The Library ==
pile.js contains, as its main function, a single object: the bistack. The bistack consists of two stacks of any data that normal JS supports, and is usually used to emulate a tape. The stacks are called "main" and "offhand", and most commands only manipulate the main stack.
The bistack has the following commands:
Command	Laconic	Description
push 	N/A 	Yields a function which PUSHes the one argument of the first function onto the main stack
drop 	$ 	POP a value and discard it
dup 	: 	POP a value and PUSH it twice
swap 	\ 	POP two values and push them in the same order, effectively swapping their locations