nyuuzyou/wikis huggingface dataset:
Poppingbrain

Poppingbrain(PoBr) is BF derivate by User:ChuckEsoteric08. It goal was to make interpreter for Turing-complete language in REALScript, because you can only make compiler in other languages that compiles 1-bit BF code in REALScript. It needed to use original version, but not REALScript++, where you can make interpreter for BF derivate.
==Commands==
It have finite number of 1-symbol stack that contains only "*" symbol. You need input how many "*"s will be in all stacks when you start program.
Command	Meaning
- 	pop * from current stack. If you popping from empty stack it will push number of "*"s that was inputed before
> 	move stack pointer right. If you are move right when pointer is on last stack, back to first.
. 	output current stack
The program run in infinitly loop, that end if current stack is empty.
==Computational class==
It would be Turing-complete if you can be able to push "*" to stack or the number of stack will be infinity, but number of stack is finite and you can't push "*" to stack. It is bounded-storage machine.
Category:Languages
Pops Are Overrated

Pops are overrated or PAO for short is an esolang where there isn't a direct command for popping off the stack. PAO was created by User:AmNow.
== Architecture ==
PAO operates on a tape-like memory composed of an arbitrary tally of stacks, arranged in a linear fashion so as to permit dextral and sinistral navigation. A cursor, known as the memory pointer, designates at any instant one of these collections as the active entity.
== Commands ==
Note: «n» means change in items on stack.
Command	Description 	«n»
€ 	Push 0. 	«+1»
0..9 	Multiply top value by ten, then add the corresponding digit. 	«0»
+ 	Subtract. Take two numbers, subtract them, and push the result unto the stack.	«-1»
- 	Add. Take two numbers, add them, and push the result unto the stack. 	«-1»
/ 	Multiply. Take two numbers, multiply them, and push the result unto the stack.	«-1»
* 	Divide. Take two numbers, divide them, and push the result unto the stack. 	«-1»
> 	Move top value to the next stack. 	«-1»
< 	Move top value to the previous stack. 	«-1»
£ 	Move the stack pointer one stack to the left. 	«0»
¥ 	Move the stack pointer one stack to the right. 	«0»
% 	Duplicate the top stack element. 	«+1»
$ 	Swap the top stack element with that immediately below it. 	«0»
^ 	Move bottom most value up. 	«0»
v 	Move top most value down. 	«0»
( 	Start loop. If the top of the stack is 0, jump past ). 	«0»
) 	End Loop. If the top of the stack is not 0, jump back to matching (. 	«0»
o 	Output the top stack element as a number. 	«0»
O 	Output the top stack element as a ASCII character. 	«0»
i 	Input a number and push it unto the stack. 	«+1»
I 	Input an ASCII character and push its value unto the stack. 	«+1»
== Programs ==
=== Truth-machine ===
 i(o)o
=== Hello, World! ===
The following program prints the text “Hello world!”:
 €72O€101O€108%OO€111O€32O€119O€111O€114O€108O€100O€33O
=== Stack Pop Cheat ===
 %+-
=== Cat program ===
The following implements an infinitely repeating cat program:
 IO(IO)
== Computational Class ==
PAO is Turing Complete, as it can simulate BF.
 BF PAO
 + €1-
 - €1$+
 < v
 > ^
 . O
 , >I
 [] ()
==Interpreter==
* Common Lisp implementation of the Pops Are Overrated programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category: Turing completeCategory: 2021Category: LanguagesCategory:ImplementedCategory:Stack-based
Popular problem

Some problems, of varying degrees of complexity, are very popular targets for esoteric programmers. Programs solving these problems are usually the first, and often the only, programs to be implemented in a new esoteric programming language.
Some of the popular problems are:
* Hello, world! - Print "Hello, world!".
* 99 bottles of beer - Print the text of the "99 bottles of beer" song.
* Quine - Output program's own source code.
* Fibonacci sequence - Output the Fibonacci numbers (1,1,2,3,5,8,13...) using either recursion or iteration.
* Factorials - Calculate n! for an arbitrary n, or output the sequence (1!,2!,3!,...), where n! = 1*2*...*n.
* Prime numbers - Output the sequence of prime numbers (2,3,5,7,11,13,17...) using e.g. the Sieve of Eratosthenes (or just brute force.)
* Disan Count - Ask the user to input a value and then print all the even numbers between 0 and that value.
* Cat program - Copy standard input to standard output.
* Digital root calculator - Calculate and print out the digital root of given input.
* Mandelbrot set - Output the Mandelbrot fractal, usually in ASCII pseudographics.
* Equivalency simulation - Interpret a language with a known computational class, e.g. Brainfuck, to prove that the language is in the same class, e.g. Turing-complete.
* Interpreter - Interpret Befunge or some other esoteric programming language not to demonstrate anything in particular, just for fun. An especially popular choice, for fairly esoteric reasons, is Deadfish.
* Bootstrap - Interpret or compile the language in which the program is written.
* ROT13 encoder/decoder - Apply the ROT13 cipher to the input text.
* Pi calculator - Calculate π to an arbitrary precision.
* Truth-machine - Get input, if 0, output '0' and quit, if 1, output '1' infinitely.
* FizzBuzz - Displays a series of numbers. However, any number divisible by three is replaced by the word Fizz and any divisible by five by the word Buzz. Numbers divisible by both become FizzBuzz.
* Infinite loop - Make an infinite loop. Itself or its variations are embedded in various popular problems. (That is why it should also be a popular problem.)
* Looping counter - Count from a specified constant to any constant.
Other popular types of programs are:
* Palindromes - Programs that read the same forwards and backwards.
* Polyglots - Programs that run in multiple languages.
Category:Program forms
Portal

Portal is a tape-based esoteric programming language designed on 10:13AM EST July 16 2014 and implemented shortly after. It is written by greato. It is a fork of brainfuck with inspiration drawn from the video game and namesake Portal.
Portal loosely implements Wang B-machine
==Instructions==
Portal has seven instructions:
Command	Description
+ 	Increment the referenced cell
- 	Decrement the referenced cell
> 	Move the pointer right
< 	Move the pointer left
. 	Output the character signified by the referenced cell
, 	Input a character and store it in the referenced cell
o 	If this is the second o portal, jump back to the instruction following the first o portal
[ 	Move the first o portal to the right
] 	Move the last o portal to the left
==Example==
This following example prints an ampersand(&):
+++++++++++++o+++++]]]]]o++++++++++++++++++++. 
and here is how this code executes, with * indicating the instruction pointer:
 *+++++++++++++o+++++]]]]]o++++++++++++++++++++.
 # omitted
 +++++++++++++o+++++*]]]]]o++++++++++++++++++++.
 ++++++++++++++o++++]*]]]]o++++++++++++++++++++.
 +++++++++++++++o+++]]*]]]o++++++++++++++++++++.
 ++++++++++++++++o++]]]*]]o++++++++++++++++++++.
 +++++++++++++++++o+]]]]*]o++++++++++++++++++++.
 ++++++++++++++++++o]]]]]*o++++++++++++++++++++.
 ++++++++++++++++++o*]]]]]o++++++++++++++++++++.
 ++++++++++++++++++]o*]]]]o++++++++++++++++++++.
 ++++++++++++++++++]]o*]]]o++++++++++++++++++++.
 ++++++++++++++++++]]]o*]]o++++++++++++++++++++.
 ++++++++++++++++++]]]]o*]o++++++++++++++++++++.
 ++++++++++++++++++]]]]]o*++++++++++++++++++++.
 ++++++++++++++++++]]]]]o+*+++++++++++++++++++.
 ++++++++++++++++++]]]]]o++*++++++++++++++++++.
 # omitted
 ++++++++++++++++++]]]]]o++++++++++++++++++++.*
As you can see from the code trace above, when the pointer reaches the first portal, the portal is not open. Only after the pointer reaches the other portal does the portal opens.
==Implementation==
The only implementation so far is written in Python:
https://github.com/greato/portal
==See also==
Portal 2
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Implemented
Category:Low-level
Category:2014
Portal 2

Portal 2 is a Portal with 2 portals.
Portal and Portal 2 loosely implement Wang B-machine
==Instructions==
Portal 2 has ten instructions:
Command	Description
+ 	Increment the referenced cell
- 	Decrement the referenced cell
. 	Output the character signified by the referenced cell
, 	Input a character and store it in the referenced cell
o 	If this is the second o portal, jump back to the instruction following the first o portal
[ 	Move the first o portal to the right
] 	Move the last o portal to the left
0 	If this is the second 0 portal, jump back to the instruction following the first 0 portal
{ 	Move the last 0 portal to the left
} 	Move the last 0 portal to the right
==Example==
This following example prints an O with diaeresis(Ö):
O++++++o----}}o]]O.
and here is how this code executes, with * marking the current instruction pointer:
 *O++++++o----}}o]]O.
 O*++++++o----}}o]]O.
 O+*+++++o----}}o]]O.
 O++*++++o----}}o]]O.
 O+++*+++o----}}o]]O.
 O++++*++o----}}o]]O.
 O+++++*+o----}}o]]O.
 O++++++*o----}}o]]O.
 O++++++o*----}}o]]O.
 O++++++o-*---}}o]]O.
 O++++++o--*--}}o]]O.
 O++++++o---*-}}o]]O.
 O++++++o----*}}o]]O.
 +O+++++o----}*}o]]O.
 ++O++++o----}}*o]]O.
 ++O++++o*----}}o]]O.
 ++O++++o-*---}}o]]O.
 ++O++++o--*--}}o]]O.
 ++O++++o---*-}}o]]O.
 ++O++++o----*}}o]]O.
 +++O+++o----}*}o]]O.
 ++++O++o----}}*o]]O.
 ++++O++o*----}}o]]O.
 ++++O++o-*---}}o]]O.
 ++++O++o--*--}}o]]O.
 ++++O++o---*-}}o]]O.
 ++++O++o----*}}o]]O.
 +++++O+o----}*}o]]O.
 ++++++Oo----}}*o]]O.
 ++++++Oo*----}}o]]O.
 ++++++Oo-*---}}o]]O.
 ++++++Oo--*--}}o]]O.
 ++++++Oo---*-}}o]]O.
 ++++++Oo----*}}o]]O.
 ++++++oO----}*}o]]O.
 ++++++o-O---}}*o]]O.
 ++++++o-*O---}}o]]O.
 ++++++o-O---}}o]]O*.
 ++++++o-O---}}o]]O.*
==Implementation==
The only implementation so far is written in Python:
https://github.com/greato/portal
==See also==
*Portal
*Brainfuck
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Implemented
Category:Low-level
Category:2014
Position

Position is a stack-based esolang created by WreckingGames, where almost every important command changes depending on its position in the code.
== Commands ==
Command	Explanation
x 	Push the x value of this character to the stack.
+ 	Increment the top of the stack.
- 	Decrement the top of the stack.
. 	Pop the top of the stack, print the result.
^ 	Print the line with the y value of the x position of this character.
* 	Pop the top of the stack.
: 	Duplicate the top of the stack.
# 	Get input from the user, if it is a number push it on the stack, else push the ascii value of it to the stack.
$ 	Pop the bottom of the stack, push it back at the top.
> 	Run the line with the y value of the x position of this character if the top of the stack is not zero.
% 	Skip the next line.
== Example Programs ==
=== Hello, world! ===
^
Hello, World!
=== Truth-machine ===
# >
%
 x.>
x.
=== Cat program ===
1 line:
#.
until 0:
#:.>
=== Add two Numbers, then output ===
##
$+$->
$.
Category:2021 Category:Languages Category:Unknown computational class Category:Unimplemented Category:Stack-based
Post-preprocessor

This esolang is made by User:A, inspired by preprocessor.
==Syntax==
=== = command===
There are three types of = commands, object-like, if-like and function-like. Object-like macros do not take parameters; function-like macros do (although the list of parameters may be empty). The generic syntax for declaring an identifier as a macro of each type is, respectively:
 <identifier>=<replacement token list> // object-like
 <identifier>(<parameter list>)=<replacement token list> //Function-like
 <condition>=<replacement token list> //If-like
Note that a function or if defenition can take more than 1 lines, as long as it ends with end.
There are, of course, operators(math,logic,comparison)which are not listed here.(They are exactly the same as in C)
Oh, just forgot to tell you how to call the function:
 function()
To use a macro value:
 macro
==Computational Class==
This is an attempt to compile Home Row into Preprocessor, using only 2(2 is enough, as said here) variable-macros.
Well, if that is wrong, you can define 8.
Define 2 variables:
 a=0
 b=0
a:
 a=a+1
Just note that a can be both a and b.
s:
 a=a-1
d and f
This does not produce direct code(Just switch the variables).
k and ;
This also doesn't produce any code, but(I think) this woultn't affect TC-ness.
j
Well, that is easy:
 n!=0=
 //1st command
 end
 //second command
l
more complicated...
 loop()=
 a != 0 =
 //Stuff all your loop commands HERE
 loop()
 end
 a == 0 =
 end
 end
There is only 1 instruction.
===Try to compile 3-cell Brainfuck===
This 3-cell no I/O Brainfuck can implement the Collatz Function, so it is Turing-complete.
Define 3 variables.
 a=0
 b=0
 c=0
+
 a=a+1
where a= any variable from a to c.
-
 a=a-1
> and <
 These don't directly produce code---they just imple switching variables.
[ and ]
 //Very complicated-don't get yourself dizzy.
 loop()=//main loop function. For nested loops, change it into loop1, loop2, etc.
 a != 0=//a is the cell you want to check
 //Stuff all your loop commands HERE
 loop()//repeat the loop function
 end
 a == 0 =//Do nothing after the cell a is 0
 end
 end
Category:Languages
Category:Turing complete
Category:Turing tarpits
Post Dominos

Post Dominos is a declarative esolang. It was discovered shamelessly ripped by User:Orby in 2019.
==Introduction==
Emil Post introduced what has come to be known as the Post correspondence problem in 1946. The tiles, or "dominos", used to model the problem are the basis of Post Dominos. A Post Dominos program consists of a finite number of dominos, each with a left string and a right string composed of a finite set of symbols. Any sequence of dominos for which the concatenation of the left strings is equal to the concatenation of the right strings is accepted by the program. All others are rejected.
==Examples==
The strings of a domino may be composed from any finite set of symbols, but we will restrict ourselves to the set {"0", "1"}. We will delimit the left and right strings with a space. An example of a domino is "101 10" where "101" is the left string and "10" is the right string. An example of a program consisting of four dominos is
 1 1101
 101 10
 01 1
 1101 1
This program accepts an infinite set of strings, one example being 
 10110111101110110110101 (*)
which is derived from the following sequence of dominos
 101 10, 1 1101, 01 1, 1 1101, 1 1101, 101 10, 1101 1, 101 10, 101 10, 01 1
Notice that the concatenation of the left strings is equal to (*), as is the concatenation of the right strings.
==Canonical programs==
For any sequences a and b that are accepted by a program, the sequences aa, ab, ba, and bb are also accepted by the program for obvious reasons.
===Hello, World!===
 "Hello, World!" "Hello, World!"
==See also==
* Thue
* :///
Category:2019
Category:Declarative paradigm
Category:Languages
Category:Implemented
Category:Turing complete
Post canonical system

A Post canonical system is a formalism for modelling logical theories, developed by Emil Post in the 1930's.
A Post canonical system contains a set called axioms, which are strings over a given alphabet of symbols. It also contains a set of productions, each of which contains a antecedent and a consequent. Each of these is what we would think of as "patterns" nowadays - a string of symbols from the alphabet, which may also contain "wildcards". Each "wildcard" in the antecedent can match any number of symbols; the corresponding "wildcard" in the consequent is substituted with the thing that was matched.
To prove a conjecture within a Post canonical system, one starts with one of the axioms and attempts to derive the conjecture by repeatedly applying the productions to it. In this way, a Post canonical system describes a formal language - the set of conjectures (strings) which the system can prove (generate).
==Example==
For example, take the following axiom:
 ()
and the following productions:
 1. n → (n)
 2. n → n()
and say we want to prove or disprove the conjecture
 (()())
We can start with the axiom
 ()
apply production 2 to yield
 ()()
and then apply production 1 to yield
 (()())
thus proving the conjecture.
==Computational class==
Post canonical systems have been shown to be in the same computational class as Turing machines, that is, they are Turing-complete. They can be seen as (probably) the first approach to string-rewriting.
Post canonical systems can have further restrictions imposed upon them and still be Turing-complete. Post normal systems, for example, can only have one "wildcard" in each production - at the end of the antecedent and the beginning of the consequent. Tag systems are even more restricted than that.
Category: Computational models
Post normal system

A Post normal system is a restricted form of Post canonical system, where only one "wildcard" may appear in each production. This wildcard must only appear at the end of the antecedent and at the beginning of the consequent. For example,
 catn → ndog
Despite this restriction, Post normal systems are still Turing-complete.
A tag system is an even more restricted version of a Post normal system.
Category: Computational models
Postfix notation

Postfix notation, or reverse Polish notation, is one of the four operator notations, and one of the three powerful notations (Prefix notation, Postfix, Surround notation), and due to ease of implementation, arguably the most powerful. It is usually used with a stack (FILO queue).
== Examples ==
 2 2 + 4 *
== Implementation ==
Postfix notation is INCREDIBLY easy to implement. The reason is simple: It directly maps to a stack operation. Here's a pseudocode algorithm to represent it:
 st = stack()
 postfixexp = input() // Assume input is always a valid postfix expression (well, don't do that, not in real programming, but this is pseudocode)
 
 exp = split(postfixexp, " ") // Split by spaces
 
 foreach(symbol in exp) {
 if isDigit(symbol) {
 st.push(int(symbol))
 }
 elif isOp(symbol) {
 if symbol == "+" {
 a = st.pop()
 b = st.pop()
 st.push(b+a)
 } else if symbol == "-" {
 a = st.pop()
 b = st.pop()
 st.push(b-a)
 } else if symbol == "*" {
 a = st.pop()
 b = st.pop()
 st.push(b*a)
 } else if symbol == "/" {
 a = st.pop()
 b = st.pop()
 st.push(b/a)
 } else if symbol == "%" {
 a = st.pop()
 b = st.pop()
 st.push(b%a)
 }
 }
 }
A more straightforward pseudocode:
st = stack()
postfixexp = input() // An invalid postfix expression is still a postfix expression.
exp = split(postfixexp, " ") // Split by spaces
foreach(symbol in exp) {
 if isDigit(symbol) {
 st.push(int(symbol))
 }
 elif "+-*/%" has symbol {
 execute(st.pop(),symbol,st.pop())
 // evaluates stack[-1] op stack[-2]
 }
}
=== Concrete Implementations ===
Example implementations of postfix expression evaluators in concrete languages:
* Haskell: here.
This is an implementation in Python supporting numbers with multiple digits:
stack = []
prog = "22 22+4*" # Our program, a postfix expression.
for x,i in enumerate(prog): # Foreach program:
 if i in "0123456789":
 if prog[x-1] in "0123456789":
 stack.append(stack.pop() * 10 + int(i))
 else:
 stack.append(int(i))
 elif i in "+-*/%":
 stack.append (
 eval (
 str(stack.pop())
 + i
 + str(stack.pop())
 )
 )
print(stack)
Category:Concepts
Category:Operator_notations
Posthumousfuck

Posthumousfuck is just Brainfuck with posthumous names as its code.
== Command Table ==
 Command Table
Posthumousfuck	Brainfuck
文 	>
武 	<
德 	+
景 	-
殇 	,
纣 	.
怀 	[
炀 	]
== Example ==
=== Hello, world ===
德德德德德德德德怀文德德德德德
德德德武景炀文德德德德德德德德
纣文德德德德德德德德怀文德德德
德德德德德德德德德武景炀文德德
德德德纣德德德德德德德纣纣德德
德纣文德德德德德德德德怀文德德
德德德武景炀文德德德德纣景景景
景景景景景景景景景纣武武武武德
德德德德德德德德德德德德德德纣
文文纣德德德纣景景景景景景纣景
景景景景景景景纣文文德纣
== Implementation ==
Implementation in Python: 
import sys
def hzfsck(code):
 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 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
hzfsck(sys.stdin.read())
== See also ==
# Hanzifuck
# Brainfurk
# Mariofuck
# Typefuck
== Categories ==
Category:Languages
Category:Turing tarpits
Category:Low-level
Category:CJK
Category:Cell-based
Category:Implemented
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:2024
Category:Turing complete
Postrado

Postrado is a programming language based on statements made by a 15 year old filipino named E.L. Mark. Created by User:Ractangle.
== Commands ==
Sentence 	Meaning
And now it's time to pack everything up	Starts the program.
Oh. And don't forget the. 	Print command. Uppercase text is literal text and gets outputted in title case (e.g. "HELLO WORLD" is "Hello World") and lowercase text are variables. And if the variable contains a special character (like an underscore or a command), it's required to be written in quotes
Were here at <funcname> [<args>] 	Creates a function. Functions look like this
 Were here at Bahmas
 £
 [Code here]
 Bahamas is shutting down
 £
Why? Because 	Condition command
I remember some memories with it 	Repeat following commands. It also functions the same way as and the command.
I think the bus is titled 	Similar to Python's input command, No argument is used
Everybody down the stairs 	Edits a variable. Also functions the same way as the Were here at command. make sure to replace the £ sign into a variable
<function> is shutting down 	Ends the function code
[n,v] 	Creates a variable
I'm quit 	End the program
Plastic bag 	Converts a variable into a different type
== Computational class ==
Using the repeat command (I remember some memories with it) as well as the conditional (Were here at) operating on a program counter variable, an unstructured machine can be emulated. In conjunction with variable editing, mathematical operators, and the conditional, increment and conditional decrement can be implemented. Assuming variables are unbounded, any Minsky machine can be translated to an equivalent Postrado program.
== Examples ==
=== Hello world ===
And now it's time to pack everything up
Oh. And don't forget the. HELLO, WORLD!
I'm quit
translated into python:
 print("HELLO, WORLD!".title())
=== Truth-machine ===
==== Without functions ====
 And now it's time to pack everything up
 [_,Plastic bag [I think the bus is titled,What a funny number]]
 Oh. And don't forget the. "_"
 I remember some memories with it [_]
 £[
 Oh. And don't forget the. "_"
 ]£
 I'm quit
translated into python:
 _=int(input())
 print(_)
 while _:
 print(_)
==== With functions ====
 And now it's time to pack everything up
 Were here at truth [x:What a funny number]
 £[
 Oh. And don't forget the. "x"
 Why? Because [x]:£[truth[x]]£
 ]£
 I'm quit
translated into python:
 def truth(x):
 print(x)
 if x:truth(x)
=== Infinite Loop ===
And now it's time to pack everything up
I remember some memories with it [1]:£[]£
translated into python:
 while 1:()
=== Cat program ===
 And now it's time to pack everything up
 Oh. And don't forget the. "I think the bus is titled"
 I'm quit
translated into python:
 print(input())
Category:UnimplementedCategory:ThematicCategory:2024Category:High-levelCategory:Flat-nestedCategory:NondeterministicCategory:Turing completeCategory:Pseudonatural