nyuuzyou/wikis huggingface dataset:
OutputF

It is a superset of Output.
==Extra command==
 Fuck value
Interpret value as brainfuck. The format of the value is the same as the format of the value in output.
==Examples==
===Cat program===
 Fuck ",[.,]"
===Brainfuck interpreter===
 Input
 Fuck the input
====Alternative====
Another one, append line feed and brainfuck code to the source code to execute it:
 Fuck the source code
For example:
 Fuck the source code
 ,[.,]
is a cat program.
Note that this interpreter may not work correctly if code contains redundant characters, for example:
 Fuck the source code
 Output ",[.,]"
will execute the cat program, then output (because the code includes an OutputF command).
==Computational class==
'cos you can invoke brainfuck with it, this esolang is definitely Turing complete!
==See also==
* Output
* Opf, a shorter version of OutputF.
Category:Languages
Category:2024
Category:Turing complete
Category:Brainfuck derivatives
Category:Pseudonatural
Over-Objective Programming Language (Opal)

The OverObjective Programming Language (called OverObjective or pronounced Opal), is a golfable language with (overly) object-oriented ideas.
OverObjective programs are simple in design, and each instruction can be simplified into the following:
* import x
* from x import y
* ClassName variableName
Notice how there is no equality, the joke about the language is the overwhelming amount of class names, although it is not a joke language.
import Parser imports the code, and import VariableOperations parses variables, so these are required to actually do something.
=== Outputting input ===
from IOMethod import InputRequest, OutputRequestFront
import VariableOperations
from String import #
import Parser
InputRequest input
prev OutputRequestFront output
Hex dump:
e0 78
== Compiling ==
The code is compiled into a hex dump, and is very compact. The number of imports takes up the first bytes. Then, the imports are compacted (each import has a unique ID) and is converted into a big integer with unique values. Then, the code is added, with the imports given previously each given their own ID, compacting the code and making it golfable.
Category:Object-oriented paradigm
Category:Languages
Category:Golfing language
Overload

Overload is an esolang made by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff in 2024 that is inspired by Underload and Emmental. Its syntax is inspired by FALSE and Befunge.
In Overload, you can redefine the instruction set.
== Instructions ==
Overload's instructions can be redefined, so this is the initial instructions.
 Caption text
Instuction	Description
' 	Push the next character to the stack
: 	Duplicate the top element of the stack
$ 	Delete the top element of the stack
! 	Output the top element of the stack, popping it.
? 	Push input on the stack
- 	Swap top two elements of the stack
[] 	Function declaration: Pop a symbol from the stack and define that to be the code inside the brackets. You may redefine a function that is being run.
== EOF ==
EOF may vary across interpreters, however the recommended approach is to use the newline as EOF.
== Conditionals ==
Overload doesn't have conditional statements, nor does it have an evaluation operator, so the only way to branch is to redefine the top element of the stack, then by executing a command.
For example, to test if the user's input is 1, and print "one" if it is:
 ?['e'n'o!!!]1
== Programs ==
=== Hello, World! ===
 'H!'e!'l::!!'o:!' !'W!!'r!!'d!'!!
=== Truth-machine ===
Define the user's input as ['1!1], then run 1. If the user inputted 1, it will go in an infinite loop.
 ?['1!1]1'0!
=== Cat program (infinite) ===
 '*[?!*]
=== Cat program (halts) ===
'^['&[]?:![-]';'&
[^]$&]
=== eafh ===
',[['0!]o]'^['&[]?:,[-]';'&
[^]$&]
=== Fixed Repeating Output (Input as unary) ===
 '=',[?:[-]'*[]'@'=
 '>[,]['>[]]@>],'
 []'%['*[]['1!%]]%0!
== Minimization ==
Since the Turing-completeness proof for Overload only uses the initial instructions []', Overload only needs 3 instructions to be Turing complete.
However, for such people who request a 2-symbol version, a variant of Overload is described here:
 2-command variation
Command	Description
: 	Push the next character onto the stack
; 	Pop two symbols off of the stack, a and b. Redefine a to the next c symbols; where c is 32 less than bʼs unicode ID.
At the end of the program the stack is printed
=== Examples ===
Hello World!: :H:e:l:l:o: :W:o:r:l:d:!
Infinite Loop: :?:!;?
== Categories ==
Category:Languages
Category:2024
Category:Stack-based
Category:Turing complete (see Overload/Turing-completeness proof)
Category:Turing tarpits
Overload/Turing-completeness proof

This is a proof that Overload is Turing complete by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff. This works by showing that a Turing complete language can be compiled to Overload.
== The Turing-complete language ==
It operates on an array of 1-bit long cells.
Commands:
 ~x: Flip the bit at cell x
 {x ... }x: While x==1 do ...
 (x ... )x: If x==1 do ...
It is turing complete because it is basically Boolf**k
== Translation ==
 ~x -> 1['x['0]'![]]!['x['1]]x!
 {x}x -> name[code'1[name]x] (Loops must be given names)
 (x)x -> x[code]1
After each command include '1[]'0[]'![].
Category:Proofs
OwOlang

A very silly esolang :3
OwOlang is an esolang made by User:Error 27 in 2023. It consists entirely of "OwO" faces and its alternative forms.
== Language overview ==
OwOlang is very similar to Brainfuck, in that its a one-dimensioanl language with a sequence of instructions. It has an infinite memory strip of 8-bit unsigned integers. There is an instruction- and a data pointer, both of which can be moved independently. There is also a single string register for output purposes.
== Syntax ==
Every instruction consists of two separate tokens, with a w in between, with each token meant to represent an eye in an OwO-like face. The first eye is an action, and the second is a motion, which defines what the action will apply to. The motion is always a relative position to the data-pointer.
== Limitations ==
The way the language is currently implemented, any additional spaces and line breaks cause errors. There is no input and no way to output numbers from the memory strip (unlike Brainfuck). All characters that are supposed to be output need to be hard coded in an instruction, which also means you cannot output a whitespace character (like space or tab).
=== Instruction set ===
Actions
Token	Description
O 	Select a cell (move the data pointer)
^ 	Increment a cell
- 	Decrement a cell
U 	Empty the string register and enter the next few instructions, depending on the number in the referenced cell, whereby their action becomes the character and the cell referenced in the motion dictates how many times the character is repeated
V 	Print out the string register the number of times in the referenced cell
T 	Continue if the referenced cell is 0, else it skips the next instruction
Q 	Continue if the referenced cell is NOT 0, else it skips the next instruction
= 	Jumps forward the number of instructions in the referenced cell
~ 	Jumps backward the number of instructions in the referenced cell
Motions
Token	Description
U 	Apply action to currently selected cell
O 	Apply action to next cell
Q 	Apply action to previous cell
p 	Apply action to a cell X spaces before the current cell
e 	Apply action to a cell X spaces after the current cell
T 	Apply action to the cell with the index held in the current cell
== Code examples ==
=== Hewwo! ===
 ^wU ^wO ^wO OwO ^wO ^wO ^wO ^wO ^wO
 UwO
 HwQ ewQ wwU owQ !wQ
 VwQ
== External resources ==
* Original interpreter on GitHub (written in Rust, has to be compiled with Cargo)
Category:LanguagesCategory:ImplementedCategory:Cell-basedCategory:2023Category:Unknown computational class
OwhelGossip

OwhelGossip also Owhel or maybe OwhelG.
OwhelGossip is best explained in a poem,
:The owl gossiped to the bat,
:The bat gossiped to bird1,
:Bird1 gossiped to the flamingo,
:The flamingo gossiped to the canary,
:The canary gossiped to the bat,
:The bat told the owl
:And so on...
The starting line for every OwhelGossip program is .,..
==Hello World in OwhelGossip==
 .,.
 .,0 ~ *<^ ~ 0)0 ~ W<o ~ @>0 ~ */* ~ G,,L ~ O-I ~ ::;U; ~ {o'o} ~ .,0
The ~ represents the "birds" "talking" to each other.
Category:Languages Category:2014
Oxon

Oxon is an esoteric programming language. Programs written in it have to use the source code for memory, making Oxon Self-modifying.
When a program is run, a copy is made of that program, which is what is executed. The original program stays unchanged.
==Language==
===Data types===
Data type 	How to write
Integer 	( )
String 	" "
String at program line	* *
There are 3 different ways of representing information in Oxon:
* (x) - interprets x as an integer
* "x" - interprets x as a string
* *x* - Interprets the contents of line x of the program as a number, if only containing numerical characters, else interpret as a string
===Commands===
In Oxon, every program line begins with a command, followed occasionally by reporters and arguments. The commands available are:
Command	What it does
P 	Prints argument A on a new line. If A is a number, print the ASCII character corresponding to that number.
W 	Writes argument A to program line B.
F 	If argument A is equal to argument B, go to program line C.
E 	Stops program.
===Reporters===
Likewise, these are the reporters available:
Reporter	What it does
A 	Takes arguments A and B. if they are both numbers, add them. If they are both strings, join them.
S 	Takes arguments A and B. if they are both numbers, subtract them.
I 	Takes user input. No arguments.
===Comments===
Comments are represented by text inside square brackets - [text]
==Examples==
===Cat=== 
 PI
===Truth machine===
 
 F(I)(1)(4)
 P"0"
 E
 P"1"
 F(1)(1)(4)
 
===Calculator===
Type the first number, then the second number, then the operation to do. It can add, subtract, and multiply.
 
 [First number of input]
 [Second number of input]
 [Operation to perform]
 [Number used for multiplying]
 W(I)(1)
 W(I)(2)
 W(I)(3)
 F(*3*)("+")(12)
 F(*3*)("*")(14)
 F(*3*)("-")(20)
 E
 PA(*1*)(*2*)
 E
 WA(*2*)(*4*)(4)
 WS(*1*)(1)(1)
 F*1*(0)(18)
 F(1)(1)(14)
 P*4*
 E
 PS(*1*)(*2*)
 E
===99 bottles of beer on the wall===
 W"99"(11)
 PA*11*" bottles of beer on the wall,"
 PA*11*" bottles of beer!"
 P"Take one down, pass it around,"
 FS(*11*)(1)(0)(9)
 WS(*11*)(1)(11)
 PA*11*" bottles of beer on the wall!"
 F(1)(1)(2)
 P"No more bottles of beer on the wall!"
 E
 [Number for how many bottles of beer goes here.]
Category:Languages
Category:Self-modifying
Category:2022
Oz

Oz is a Wizard of Oz-inspired esoteric programming language created by User:Star651 on January 13, 2013. The variable names can be more than one word, and can be abbreviated. For example, the variable over the rainbow can be shortened to over, and Scarecrow can be shortened to Scare. The concept of this language is, you have the variables, which are the main Wizard of Oz characters. Dorothy, Scarecrow, Tinman, Lion, and Wizard. (Note, even though in the movie, the Wizard calls himself Oz, it is Wizard in the programming language for ease of reading and understanding) Most variables can contain numbers, strings and booleans, but the wizard is more of an object than a variable. It contains objects such as heart, brain and courage.
put wizard heart in tinman
put wizard brain in scarecrow
Another variable is over the rainbow. This is used to produce output. So, put dorothy over the rainbow would output the contents of the Dorothy variable. The contents of these variables can be anything. For example, the following code would print out the word pinwheel.
dorothy=pin
scarecrow=wh
tinman=ee
lion=l
put dorothy over the rainbow
put scarecrow over the rainbow
put tinman over the rainbow
put lion over the rainbow
Of course, you don't have to do all that work to write pinwheel; this is just a multi-variable example. You could give Dorothy the whole word, and she could go over the rainbow with it, like this:
dorothy=pinwheel
put dorothy over the rainbow 
Or, you could give scarecrow a pin brain, and tin man a wheel heart (both from the wizard), and no one would know the difference.
wizard brain=pin
wizard heart=wheel
put wizard brain in scarecrow
put wizard heart in tinman
put scarecrow over the rainbow
put tinman over the rainbow 
It doesn't matter; as long as Dorothy gets home. That's why all programs must end with put dorothy home. Putting any character variable "home" deletes it from memory. Who cares anyway? This is just a Wizard of Oz fanfic for the programmers out there!
category:languages
category:2013
Category:Pseudonatural
Category:Thematic
Ozone

Ozone is an stack-based language created by User:Set. Program flow in Ozone is controlled by the mechanism of spawning new stacks, copying them, and executing.
==Language Overview==
An Ozone program is a set of characters that will be pushed onto stack 0 and set to execute when the program is run. All stacks initialize to (0), and when the last item on a stack is popped, it will go back to (0).
Parentheses are used around the lists. For example (100,52,8) would be a valid list. For ease of programming, lists are pushed onto the stack beginning with the last item, so that you don't have to write everything backwards.
Within a list, angles are used around sets of characters. So (1,<Hello World>,7) would be a valid list.
Command 	Description
s* 	Spawn new stack numbered *
v*() or *2 	Push list onto stack *. If () is given, use that, if *2 is given, use that stack as the list.
e* 	Execute stack *. This will interpret the top item as a command, then pop it and continue all the way through the stack.
c* 	Displays the top of stack * as an ASCII character
n* 	Display top of stack * as a number
p* 	Pop item at top of stack *
u* 	Increment stack *
d* 	Decrement stack *
Pops stack * and adds 	
Pops stack * and subtracts	
** 	Pops stack * and multiplies
/* 	Pops stack * and integer divides
i* 	Accept a character of input and direct to stack *
b* 	Break (stop executing and clear stack) if stack * is <= 0
[n*] can be substituted in anything. It will be interpreted as the value of stack *.
Stacks can push lists onto themselves, where they will appear right after the command that did that.
==Examples==
These examples may have bugs in them, since there isn't an interpreter to test them with.
===Hello, World!===
This will output "Hello, World!"
Easily-readable w/comments:
 (s1v1(<Hello, World!>) |Push the string "Hello, World!" onto stack 1
 s2v2(< |Begin pushing a list onto stack 2
 c1p1 |Print stack 1 and pop
 b1v02>) |Break if 0, push stack 2 onto stack 0, end list
 v02) |Push stack 2 onto stack 0
===Fibonacci===
This will output the Fibonacci sequence.
Standard:
 (s1v1(1)n1n1s2v21v21s3v3(<+2n2v12+1n1v21v03>)v03)
Easily-readable w/comments:
 (s1v1(1)n1n1 |Push 1 onto stack 1 and print twice
 s2v21v21 |Push stack 1 onto stack 2 twice
 s3v3 |Begin pushing a list onto stack 3
 (<+2n2 |Add stack 2 and display
 v12 |Push stack 2 onto stack 1
 +1n1 |Add stack 1 and display
 v21 |Push stack 1 onto stack 2
 v03>) |Push stack 3 onto stack 0, end list
 v03) |Push stack 3 onto stack 0
==Everything else==
The author thinks this language is Turing-complete, but has no current proof.
Currently, there is no interpreter, since the author does not know how to implement one.
Category:Languages
Category:Stack-based
Category:Unimplemented
Category:Unknown computational class
Oş Nõs

Oş Nõs (Pernounced "O S Nose" becsuse i hate sense) is programming language made by Someone668 on June 13th, 2022. It is ment to look like a conversation.
== Functions ==
* "<string>" - Prints to the console
* Listen kid, <string> ok? Ok. <function> - Asks the user if it's ok do do a function.
* "<string>"? - Asks the user for input. Automatically guesses if it's an integer or string.
** Yes? <string/function> - Happens if the user says yes.
** No? <string/function> - Happens if the user says no.
** Really? <user's input>? <string/function> - Happens if the users input is <user's input>.
* Did you know "<variable>" Is "<integer/string/user input>"? - Declares that a existing or new variable is <integer/string>.
* Wait, "<variable>" IS "<integer/string>"? Well then,
**<function>
Wellthen - Function happens if the variable is <integer/string>.
* What is <variable/integer> <operation/variable> <variable/integer>? - does math with two numbers.
* Copy him/her! - Says what the user inputs.
* Repeat
**<functions>
Hey, can you repeat that please? * <integer> - repeats a function for a curtain amount of time..
* Get it? "<string>"? - comments on code
* /w <string> - filler string
== Programs ==
Programes: calculator. 
=== Calculator ===
 1 Repeat
 2 Did you know "a" is "What's the first number"??
 3 /w wow! I didn't know that tell me another fact!
 4 Did you know "b" is "What's the second number"??
 5 /w wow! I didn't know that tell me another fact!
 6 Did you know "c" is "What's the operation"??
 7 /w wow I didn't know, but
 8 What is a c b?
 9 Hey, can you repeat that please? * 65535
OΔTS

:Not to be confused with Oats.
OΔTS(pronounced OATS) is a esolang created by User:Yayimhere
== memory ==
memory is a stack holding floats.
== commands ==
 commands
command	meaning
W(n) 	pop the top of the stack and push the first digit of it mod n. if the digit is 0 push 1 unless n=10
[...] 	loop ... while top of stack is not 0
<(n) 	pop top of stack. if its equal to n then push 1 else push 0
" 	duplicate top of stack
Q(n) 	goto line n
{n} 	push n
! 	pop top of stack
~(n) 	pop top two values of stack(first popped is A, and second popped is B) then do Log_{B}(A) then take the digital root of that and push the result. if B is 0 however, A will be multiplied by n and then push the result
; 	move top of stack to the bottom
= 	swap top two values of the stack
 	negate top of stack
? 	pop the two top elements of the stack and a add them together with the first popped being on the left side of the operator
== TC proof ==
this translates to brainfuck:
 starts code with {1}{1}{1}
 > -> ;
 + -> {0}=~(2)
 - -> {0}=~(0.5)
 [...] is itself
note that output input would not work since techincally are 
Category:Languages Category:Stack-based
O⟴o+vFuck

o⟴o+vFuck is like brainfuck but it uses substitution and special unicode char's. yes i will be calling it chars.
these are the commands in o⟴o+vFuck
 
o⟴o+vFuck symbol	brainfuck	description
↛ 	> 	Move the pointer to the right
↚ 	< 	Move the pointer to the left
∐ 	+ 	Increment the memory cell at the pointer
⌦ 	- 		Decrement the memory cell at the pointer
⌆ 	. 		Output the character signified by the cell at the pointer
⌅ 	, 	Input a character and store it in the cell at the pointer
《 	[ 	Jump past the matching 《 if the cell at the pointer is 0
》 	] 	Jump back to the matching 》 if the cell at the pointer is nonzero
now we get to things added:
 Caption text
symbol 	description
A=B 	for N(n is defined as the first cell or $1) iterations replace A with B
A=B?C!=D	replace A with B for N iterations if and only if C is not equal to D
A=B?C=D 	A=B?C!=D but if and only if C IS D.
$A 	cell with index A so fro example: A=B?$C!=$D is if and only if cell with index C is not equal to cell with index D. this can also be used in scripts. if used in the normal malbolge script write any command then []'s and then inside those a index it will be used in the command so ∐[$1] will increment cell 1
a simple usage of the replacement is:
 SUB[
 A=+++++++++++[>++++++>+++++++++>++++++++>++++>+++>+<<<<<<-]>+++
 +++.>++.+++++++..+++.>>.>-.<<-.<.+++.------.--------.>>>+.>-.
 ]
 A
when ran A is replaced with the hello world program and then it reruns the program
Category:Languages
Category:Brainfuck derivatives
P

P is an esoteric programming language created by StelK around December 2005.
It has several commands for stack manipulation, conditional statements, file handling and so on...
In the site indicated below you can found some more documentation and an interpreter written in C++.
==Examples==
Text between "" is printed on the screen, P recognize the \n sequence. Here is a Hello World program:
 
 "Hello World\n"
Fibonacci's numbers:
 99*8+t#21"1 "<\a+$a^" "[t@]>@
99 bottles of beer:
 1z99*9+9++n<1-[z"1 bottle of beer on 
 the wall\n""Take one down and pass 
 it around\n"@]^" bottles of beer on 
 the wall\n"^ " bottles of beer.\n""
 Take one down and pass it around\n"
 >@"No more bottles of beer on the wa
 ll\n"&
==External resources==
* (Italian)
* (English) manual and interpreter (gzipped tar)
Category:Languages
Category:Stack-based
Category:Implemented
Category:2006
P0pCrn

P0pCrn is an esolang made by Areallycoolusername. It's based off of x86 Assembly and it has cells. 
== Specifics ==
P0pCrn code is made up of four columns. This is similar to Assembly, which has only three columns. One is for the code that will be executed, another is for variable declaration, and the other is for comments. There is also a space reserved for a "_!" Declaration. These sections are declared through "_P", "_0", "_p", and "_!". With out them, the interpreter dosen't know which section is supposed to hold code, variables, comments, or the ending column. You put comments under _P, code under _0, variables under _p, and the ending declaration under _!. Each column is separated into an infinite amount of rows, and therfore, an infinite number of cells. Code, comments, variables, and the end declaration can only take up 2 characters in each cell. If your code only requires two columns, you can omit the column you don't need. If your info only takes up one character of a cell, you must enter an underscore to fill the cell. Not filling the cell will result in a deformed corn and an error message. When using the msg op command, white spaces in your phrase must be replaced with an underscore.
== Commands ==
Command	Function
@op 	Starts a comment in the comment column.
#op 	Starts code in code column.
$op 	Starts a variable in the variable section.
msg op 	Prints a message.
str op 	Used to declare strings in the code.
int op 	Used to declare integers in code. (floats count as integers here)
boo op 	Used to declare booleans in code.
== Hello World ==
_P _0 _p _!
@o #o $o st
p_ p_ p_ r_
Th ms P0 op
is g_ pC 
is op rn
wh P0 =_
at pC He
co rn ll
mm o_
en wo
ts rl
lo d!
ok
li 
ke 
in
P0
pC
rn
!
Outputs "Hello, world!"
Category:Languages
P1eq

P1eq (plus one and branch if equal) by User:Oleg is a Subleq derivative with an instruction
 A B C
and the meaning B=A+1 and jump to C if B does not change.
==Hello, world!==
Using the Subleq assembly language "Hello, world!" program is straightforward 
 # output *p; 
 p a
 a:0 (-1)
 
 # p++
 p p
 
 # check if p!=E
 p t
 E t (-1)
 Z Z0 0
 
 . p:H-1 Z:-1 Z0:0 t:0
 . H: "Hello, World!\n" E:E-1
==Arithmetic sum==
The instruction is probably enough to make more complex computation. For example, the following program prints "2" (ASCII value 50) after summing x and y.
 t1 t1
 y y
 t1 t2
 x t2 end
 Z Z0 0
 end: y (-1)
 Z Z0 (-1)
 . Z:-1 Z0:0 t1:0 t2:0 x:30 y:20
==Implementation==
Use sqasm.cpp to compile assembly program into the P1eq code. Then sqrun.cpp with the option (-p) to run the compiled code.
==See also==
* Addleq
* Subleq
* DJN OISC
Category:Languages
Category:Implemented
Category:2009
Category:Self-modifying
Category:OISC