nyuuzyou/wikis huggingface dataset:
Ook!

Ook! is a joke esoteric programming language created by David Morgan-Mar. It is identical to Brainfuck, except that the instructions are changed into Orangutan words. It represents the first in a long line of Brainfuck command substitutions. As such, it is a member of the TrivialBrainfuckSubstitution family of programming languages.
==Commands==
Brainfuck	Ook! 	Description
> 	Ook. Ook? 	Move the pointer to the right
< 	Ook? Ook. 	Move the pointer to the left
Ook. Ook.	Increment the memory cell under the pointer	
Ook! Ook!	Decrement the memory cell under the pointer	
. 	Ook! Ook. 	Output the character signified by the cell at the pointer
, 	Ook. Ook! 	Input a character and store it in the cell at the pointer
[ 	Ook! Ook? 	Jump past the matching Ook? Ook! if the cell under the pointer is 0
] 	Ook? Ook! 	Jump back to the matching Ook! Ook?
n/a 	Ook? Ook? 	No operation
==Hello, world! program==
 Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook.
 Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook?
 Ook! Ook! Ook? Ook! Ook? Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook.
 Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
 Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
 Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
 Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
 Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook!
 Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook! Ook.
== See also ==
* 啊！
* Ook!+
==External resources==
* OokBF, an online interpreter for the Ook! language, and a cross-platform runtime environment. Includes an online language converter.
* DM's Esoteric Programming Languages - Ook!
* esco - universal interpreter of esoteric languages
* The Librarian - Discworld and Terry Pratchett Wiki
Category:Brainfuck derivatives
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2001
Category:Pseudonatural
Category:Turing tarpits
Category:Languages
Oops! all functions

Oops! All functions is a dumb esolang/challenge that User: Froginstarch thought about when he was incredibly bored
The premise of this esolang is that you can only use functions (user defined) for every thing, not tradional control flow is allowed if you are using a language that allows for it
== Syntax ==
The syntax for function definitions is
 function name -> (args) {function body} 
Category:Languages Category:Unimplemented Category:Functional paradigm Category:2024
Oozlybub and Murphy

Oozlybub and Murphy is an esoteric programming language designed by Chris Pressey. The first version was released on Dec 1, 2010, but the design incorporates several ideas from earlier years, dating back to at least 2006. These ideas include multiple interleaved parse streams, infinitely-long variable names, gratuitously strong typing, and only-conjectural Turing completeness.
==Overview of Program Structure==
An Oozlybub and Murphy program is composed of a number of program elements called dynasts. Each dynast contains an expression, which is evaluated when the dynast is executed, and is labelled with a positive integer. Execution begins at the dynast with the smallest label, n. When dynast n has finished executing, dynast n+1 is executed, and so forth, until no dynast with such a label exists, at which point the program halts. (The program can halt under other conditions too.)
Once executed, a dynast can never be executed again; thus, control flow is monotonic, in a manner similar to that of SMITH. Although only a finite number of dynasts may be specified in the program text, new dynasts can be created dynamically by the program, as a side-effect of evaluating certain expressions. However, there are restrictions on the labels given to these dynamically created dynasts: the labels must be either odd integers (in the create/countably/many/dynasts expression), or the sum of two prime numbers (in the copy/dynast expression).
==Computational Class==
Although no proof has been constructed, Oozlybub and Murphy is thought to be Turing-complete if and only if Goldbach's Conjecture is true. If Goldbach's Conjecture is not true, it is not possible for an Oozlybub and Murphy program to enter an infinite loop, because there will be some even-numbered dynast that cannot be created because its label is not the sum of two primes. But if Goldbach's Conjecture is true, it is possible for an Oozlybub and Murphy program to loop an unlimited number of times, and the language's set of built-in functions is thought to be powerful enough that each time through the loop it can simulate one state transition of some fixed, arbitrary Turing machine.
==External resources==
* 
Category:Languages
Category:Unimplemented
Category:2010
Category:Unknown computational class
Op

==Commands==
Output 	Op
Input 	i
Output the input 	oi
Output the program's source code	os
Output "string" 	o"string"
Like Output, the o command raises a syntax error if you passed it wrong values.
==Example programs==
===Hello World===
 o"Hello World!"
===Cat program===
 ioi
===Cheating Quine===
 os
===n^2 program===
 ososos
n is the number of os's. Every os prints n os's, thus outputting n^2 os's. Refer to the n^2 program in Output for more details.
==See also==
* Output
* Opf, a superset of Op.
Category:Languages
Category:Total
Category:2023
Category:Low-level
Opera Ghost Language

[] means optional, () means can be modified according to the programmer
Variables and constants:
1. To declare a variable:
 let [(type)] (name) be (value), Ex: let num be 1
2. If you do not want to initialize the variable, you can do this:
 let [(type)] (name) be your freedom, Ex: let toinput be your freedom
3. To define constants:
 let [(type)] (name) as unchanging as the sea be (value), Ex: let c as unchanging as the sea be 299792458
4. Getting the address of a variable:
 where in the world has (variable) been hiding
5. Dereferencing pointer:
 what has (pointer) to hide
 or
 angel or father friend or phantom who is it at (pointer)
1D Arrays:
1. Creating an array: 
 let [(type)[(length)]] (array_name) be (value) and (value) and ... in one combined
2. Setting value at index: 
 (value) shall watch the performance from its normal seat in (array) (index)
nD Arrays (Ex. 2D array):
1. Creating an array: 
 let [(type)[(length)][(length)]] (array_name) be ((value) and (value) and ... in one combined) and ((value) and (value) and ... in one combined) and ... in one combined
2. Setting value at index:
 (value) shall watch the performance from its normal seat in (array) (index) (index)
structs:
1. Creating a struct (the type is optional if the compiler can deduce the type of (default_value)):
 let the opera (struct_name) begin
 cast (default_value) as (type) (member1_name)
 cast (default_value) as (type) (member2_name) 
 ...
 it's over now the opera (struct_name)
 let (struct_name) (variable_name) be (value) and (value) and ... in one combined
2. Creating an anonymous struct: 
 let [type1 and type2 and ...] (struct_name) be (name) is (value) and (name) is (value) and ... in one combined
Category:Languages
Category:Pseudonatural
Opf

It is a superset of Op. It is also a shorter version of OutputF.
==Commands==
Output 	Op
Input 	i
Output the input 	oi
Output the program's source code	os
Output "string" 	o"string"
Fuck the input 	fi
Fuck the program's source code 	fs
Fuck "string" 	f"string"
Like OutputF, the o and f commands raises a syntax error if you passed it wrong values.
==Examples==
===Cat program===
 f",[.,]"
===Brainfuck interpreter===
 ifi
====Alternative====
Another one, append brainfuck code to the source code to execute it:
 fs
For example:
 fs,[.,]
is a cat program.
Note that this interpreter may not work correctly if code contains redundant characters, for example:
 fso",[.,]"
will execute the cat program, then output (because the code includes an Opf command).
==Computational class==
'cos you can invoke brainfuck with it, this esolang is definitely Turing complete!
==See also==
* Op
* OutputF
Category:Languages
Category:2024
Category:Turing complete
Optimism

Optimism is another implementation of the OISC idea, this one by ToothPic, but it's a little different in that it's based on addition, not subtraction. That is where it's name came from. Addition is giving, optimistic. The only instruction is ADDOV, which takes three operands. Code and data are separate, and memory mapped I/O is available.
==Instruction layout==
All data is one byte long. The Program Counter can be any number of hex digits long. One byte will be used on this page.
As the only instruction is ADDOV, it isn't shown in the code. The three operands are written in hexadecimal form, with commas between the numbers and a terminating newline.
 1C,AA,07
The first operand is the destination, followed by the source and finally the location for the jump. The jump is to a literal line number, and has to be included, even if it's unused.
FF is a reserved number in every field. If FF is in the jump field, it specifies that the source value is literal. If the source is FF, program prompts for input to the destination. If the destination is FF, then the number in source is output as an unsigned integer.
 x,x,FF The second operand is literal. Always goes to the next instruction, even on overflow
 01,AA,FF This adds AA(170) to data memory location 1
 x,FF,x The program will prompt for input
 01,FF,00 The program will put the users input in 1. If n < 0 or > 255, a 0 will be stored
 FF,x,x The program outputs the value of the source
 FF,01,00 If location 1 is 42, the program will output 42
Execution halts when the program reaches location FF. On a side note, no matter if the PC is 4-bits or 24-bits, the highest possible value for the PC is the endpoint and the immediate value flag. Just fill all digits with F's.
Comments are allowed in the code only if the jump pointer is followed by a comma, and include no commas.
==Making ADDOV do SUBNP==
To do subtraction, assuming 00-01:
 03,01,FF,Make 03 = 1
 00,03,06,Add 1 to 00
 02,03,00,Add 1 to 01
 03,01,FF,Add 1 to 03
 04,FF,FF,Make 04 = 255
 03,04,01,Add 255 to 2, making 03 = 1 and forcing a jump to 01
 02,02,FF,Correct for the missed increment + inherent error
 00,01,08,Add 01 to 00
 00,02,09,Add inverse of 00 to 00
To test if 00 < 0:
 01,80,FF,Make 01 = 128
 00,01,x,Will only jump if highest bit is set, which is set in negative numbers.
That will jump to x if 00 < 0.
Using those two code snippets, and maybe some more code, it is possible to implement Subtract and branch if Not Positive.
==Examples==
Here is a program which prints the ASCII values of "Hi!":
 00,48,FF,Move 72 ("H") into 00
 FF,00,02,Print 00
 00,21,FF,Add 33 to 72 to make 105 ("i")
 FF,00,04,Print 00
 00,B8,FF,Add 184 to 105 to make 289. 289 % 256 = 33 ("!")
 FF,00,07,Print 00
==Compiler==
In March of 2012, User:shadwick wrote a naive but functional Optimism-to-C translator. Just pump the resulting C through your favourite compiler, link it, and you're good to go. The source can be found here: http://paste.pocoo.org/show/567221/ 
==See also==
*OISC
*Subleq
*MISC
*Subskin
Category:Low-levelCategory:LanguagesCategory:Turing_completeCategory:Turing_tarpits
Category:2008Category:OISC
Or++

Or++ is a minimalist esoteric programming language created by User:TheCanon2. It is a superset of or.
==Commands==
Or++ has a single stack. Or++ has 6 commands.
Command	Hex 	Action
f 	0x20 0x66	Push false to the stack
t 	0x20 0x74	Push true to the stack
p 	0x20 0x70	Pop the top of the stack
r 	0x20 0x73	Reverse the entire stack
h 	0x20 0x31	Halt if the stack is empty
j 	0x20 0x72	Jump to the first instruction
Or++ also accepts an input of t and f commands, which are pushed to the stack.
==Examples==
===Quine===
 f
===Collatz sequence===
Translated_from cyclic_tag system
 f t f f f t r p r h t f f r p r h t f f t f f t f f r p r h r p r h r p r h r p r h j
===Computational class===
If Or++ had conditional checking for true and false, it would be Turing-complete because it would be possible to compile a cyclic tag system into Or++.
 f Would append 0 to the data string.
 t Would append 1 to the data string.
 r p r h Would delete the first bit of the data string.
 j Would repeat the loop.
==Implementations==
The following Python script is an interpreter.
prgm = " " # Python doesn't read spaces at the beginning of an input
init = " "
stack = []
prgm += input('>prgm ')
init += input('>i ')
for i in range(0, len(init), 2):
 j = .join([init[i],init[i+1]])
 if j == " f":
 stack.append(" f")
 elif j == " t":
 stack.append(" t")
 else: pass
# Executes the program
inst = 0
while inst < (len(prgm)/2):
 cmd = .join([prgm[2*inst], prgm[2*inst+1]])
 if cmd == " f":
 stack.append(" f")
 elif cmd == " t":
 stack.append(" t")
 elif cmd == " p":
 stack.pop()
 elif cmd == " r":
 flip = [] # reverse() doesn't work for me
 for i in range(len(stack)-1, -1, -1):
 flip.append(stack[i])
 stack = flip
 elif cmd == " h":
 if len(stack) == 0:
 break
 elif cmd == " j":
 inst = -1
 else: pass
 inst += 1
 print(stack)
Category:Joke languages
Category:Stack-based
Category:Unknown_computational_class
Category:Implemented
Category:2024
Category: Languages
Oracle

Oracle is an esoteric language by User:Rdococ. It's like any other language, except it has a halting oracle which takes in a function and returns whether the function will halt or not. While it is super-turing complete in the sense that it can solve the halting problem for both Turing complete programs and Oracle programs, I honestly didn't find it to be that particularly useful, except for maybe optimizing boolean-returning functions.
== Examples ==
// This function either destroys the universe, somehow avoids being run in any universe or causes an error message, depending on implementation.
// Note that if the hypothesis of quantum suicide holds true, then the two former possibilities are equivalent.
// The third may be too, if someone's holding you hostage and will kill you if you cause an error message.
// Well, unless you cause an error message and then escape before they can kill you.
// There's also the off chance that you can survive the destruction of the universe.
// TL;DR, don't run this code.
function paradox() {
	if (halts(paradox)) {
		while (true) {
		};
	} else {
		return;
	};
};
paradox();
// This function checks whether x is prime, at the speed of the halting oracle rather than the speed of the function itself. All functions that return a boolean can be optimized this way.
function isPrime(x) {
	return halts(function (x) {
		var i = 2;
		while (i < x) {
			if ((x/i)%1 == 0) {
				return;
			};
			i++;
		};
		while (true) {
		};
	}, x);
};
Category:UncomputableCategory:2017
Orbit virtual machine

The Orbit virtual machine or Orbit VM is an esoteric programming language used in the ICFP 2009 programming contest. 
Orbit programs run their instructions in sequence in a loop, and there are no jump instructions that can change this order. Every instruction has an associated memory cell storing a 64-bit floating-point value, and the instruction writes its value to that cell. The input operands of the instructions are also memory cells, with their absolute address encoded in the instruction. There are instructions for floating-point add, subtract, multiply, divide, square root, identity, ordered comparison with zero, and a branchless conditional that results in one of its two inputs depending on the result of the previous comparison. There are also instructions to read or write IO devices. 
In the contest, Orbit virtual machine programs written by the contest organizers simulate the mechanics of a satellite orbiting Earth. The contestants must figure out what commands to supply to the thrusters of the satellite using the input ports of the Orbit virtual machine program.
== External links ==
* Contest homepage
* Contest task specification, saved by the Internet archive
Category:Languages
Category:Cell-based
Category:ICFP contest
OrdinalFuck

OrdinalFuck is a hypercomputable programming language. It is a brainfuck derivative with the ability to solve the Halting problem. OrdinalFuck was inspired by and takes influence from Hyperon.
== Memory ==
The memory system is similar to brainfuck. There is a bi-infinite tape of memory locations. Different from brain fuck however each of these locations can store an ordinal number. For set-theoretic reasons, we will consider OrdinalFuck to actually be an infinite class of programming languages called OrdinalFuck_n where n is an ordinal number and the largest ordinal aloud in that language. If a spot in memory is incremented larger than its largest ordinal it will wrap around back to 0.
== Instructions ==
There are two families of instructions in OrdinalFuck. The first are those from brain fuck. They are listed here for reference. 
Command	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 (if limit ordinal do nothing)
. 	Output the ordinal signified by the cell at the pointer
, 	Input a ordinal 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
The next set of commands are specific to OrdinalFuck_n. They are both forms of brackets that are put on the outside of strings of code.
Command	Description
(*) 	Run the code written as * infinitely over a blank tape. Write the supremum of all the ordinal numbers written on that tape to memory at the current location.
{*} 	open up an instance of OrdinalFuck_m (where m is the ordinal at the current memory position) and run the code writen as * on it. If the code terminates increment the curent memory position, else dont.
== References ==
Category:Languages
Category:Uncomputable
Category:Brainfuck_derivatives
Category:Unimplemented
Category:2021
Oroogu

Oroogu is a language created by Georg Kraml based around the queue as its sole data structure and a "While Object X Contains One or More Items" loop as its main system of flow control. Original documentation is difficult to come by since Kraml's site went down, but the language is simple enough to give a basic overview.
 d = ()
 foo = (1 2 3..7) (d / foo)
This sample program consists of a queue named foo, and output queue named d, and a loop. Foo contains the items within the first set of parentheses, ".." is the range operator and indicates all integers between the two operands (infix notation). d starts out empty, but when foo is evaluated, each item in foo is removed and appended to d. By definition, all queues with a name beginning with or consisting only of d are sent to output at the end of the program run, so the program given has the following output:
 1 2 3 4 5 6 7
== External resources ==
* 
Category:Languages
Category:Implemented
Category:Queue-based
Category: 2000
Orthagonal

Orthagonal is a two-dimensional esoteric programming language created by Jeff Epler in 1994 after a discussion about two-dimensional languages in alt.folklore.computers.
==See also==
*Orthogonal
*Befunge
==External resources==
*Original Usenet post
*GitHub repository hosting the language specification, interpreter and example programs
Category:Languages
Category:Stack-based
Category:Unknown computational class
Category:Two-dimensional languages
Category:Implemented
Category:1994
Orthogonal

Orthogonal is a two-dimensional esoteric programming language created by Brian Raiter in 1996. Orthogonal was based on the language Orthagonal. According to the home page, Orthogonal was created without the knowledge of Befunge, an influential two-dimensional language invented earlier, but whether the author of Orthagonal was also aware of Befunge is not known.
==See also==
* Orthagonal
* Befunge
==External resources==
* Orthogonal home page
Category:Languages
Category:Stack-based
Category:Unknown computational class
Category:Output only
Category:Two-dimensional languages
Category:Implemented
Category:Low-level
Category:1996
Outinp

Outinp is an esolang created by User:Win7HE, not made for code golfing and probably turing complete.
==Commands==
Any # can be replaced by a diffrent character. Any $ can be a comment, or replaced by a space.
out##### - outputs the #'s.
inp##### - asks you for 5 character input with reason that is the #.
oui$$$$$ - outputs input
emp$$$$$ - a newline (new empty scratch list item)
1in##### - increases variable 1 by #####. (if negative number decreases variable)
2in##### - increases variable 2 by #####. (if negative number decreases variable)
iff###$$ - if variable 1 not ### skip next command
swp$$$$$ - swaps variable 1 and 2's values
ouv$$$$$ - outputs ascii value mapped variable 2
jmp##### - jumps to command #####
ini$$$$$ - increases variable 1 by input (input, not hashtags)
nop$$$$$ - a no operation command.
==Example Programs==
===Cat===
inpimcatoui/////inpimcatoui/////inpimcatoui/////
===Truth Machine (please fix this code or interpreter)===
out123 iouts 1, outelse outzero.inpinputini.....emp.....iff123..jmp00009jmp00012out11111jmp00009nop.....out00000jmp00012
===Hello World===
outHelloout, woroutld!..
==The Only External Link==
* Official Interpreter written in Scratch
Category:Languages
Category:2024
Category:Implemented
Output

Output is an esolang invented by User:None1.
==Commands==
 Input
Reads a line of input
 Output value
This can output a string if the value is surrounded by quotes (""), but there also two special values without quotes:
 the input
is the result of the last command, if no input command is executed before, do nothing.
 the program's source code
is the program's source code.
This command does not output any line feed or space after outputing value.
Other values raise a syntax error, but an incorrect command is ignored.
It is case sensitive, and first letter of each line must be capitalized.
==Examples==
===Hello World===
 Output "Hello World!"
===Cat program===
 Input
 Output the input
===Cheating quine===
 Output the program's source code
===Syntax error===
 Output 1
===n^2 by Infinitehexagon (TIO)===
 Output the program's source code 
 Output the program's source code
 Output the program's source code
n = the amount of "Output the program's source code" lines
For some reason TIO squares the amount of "Output the program's source code"'s in the interpreter, thus making an n^2 program
==Interpreter==
===Python===
inp=''
lines=[]
def execute(c):
 global inp
 c=c.strip()
 if c=='Input':
 inp=input()
 elif c.startswith('Output '):
 val=c[7:].strip()
 if val=='the input':
 print(inp,end=)
 elif val=="the program's source code":
 print('\n'.join(lines),end=)
 elif val[0]=='"' and val[-1]=='"':
 print(val[1:-1],end=)
 else:
 raise SyntaxError('Unrecognized value format')
while 1:
 try:
 x=input()
 except:
 break
 else:
 lines.append(x)
for i in lines:
 execute(i)
Try it online! (Use a line with only one character "!" to separate program and input if there is input)
==See also==
* Op, a shorter version of Output.
* OutputF, a superset of Output.
Category:Languages
Category:Total
Category:Unusable for programming
Category:Pseudonatural
Category:2023
Category:Implemented