nyuuzyou/wikis huggingface dataset:
ODDBALL

ODDBALL, possibly an acronym for One Dimensional Deterministic Bully Automaton Layout Language, was created some time in the early 2000's by Tristan Parker for some reason or another. Its roots can be traced back to Lisp and ALPACA, though why anyone would do that is beyond me. In 2005, ODDBALL was released into the public domain, not through any sense of community enrichment, but out of sheer laziness.
==Structure==
Like Thue, ODDBALL is a matrioshka language; each program has an Imperative section and a Declarative section. The Imperative section contains commands in a FORTH like language defining states of a bully automaton, and the Declarative section contains one or more starting states and instructions on how to process them.
===First glance===
 Imperative section
 [
 [[@/'x@/'o~]'o>]
 [[@\'x@\'o~]'o>]
 ]
 Declarative section
 |"xxxxxxxxxxxxxoxxxxxxxxxxxx"|?|
The imperative section is surrounded by square brackets ([]) that can also be used to visually break up the program and offer scoping of local variables. The declarative section is surrounded by pipes (||) and also divided by them into blocks which give instructions on the creation of a one dimensional bully automaton.
==Commands and structures==
===Imperative commands===
Imperative commands are written using postscript notation (like Forth) and define the behaviour of bully cells.
 @ A placeholder for "this cell", refers to the behavior of all cells.
 ' Indicates that the following character is the name of an object.
 / Indicates the cell to the immediate right of the cell in scope, bringing
 that cell into scope.
 \ Indicates the cell to the immediate left of the cell in scope, bringing
 that cell into scope.
 ~ Sets the cell in scope to the object indicated.
 > Stores the preceding function delineated by [] into the behavior of the
 object indicated.
===Declarative structures===
A list of automata are read left to right, but not evaluated unless other commands are encountered in the place of automata. In general, each automaton is treated as unbounded finite, unless indicated otherwise.
 |x*o| Treat the following automaton as bounded on the left by 'x's and the
 right by 'o's.
 |?| Evaluate the previous automaton iteratively, storing states in a buffer,
 and comparing each new state to all previous states until the new state is
 the same as a previous state, then stop and move to the next automaton.
 |!| Evaluate the previous automaton a single generation.
 |7!| Evaluate the previous automaton seven generations.
 |"hello"!| Evaluate one generation of the previous automaton and append the
 string of objects "hello" to the left side of the automaton.
 |s/a*a/ab1a/| Perform a regex substitution on the
 previous automaton (the code given replaces; for example, "aca"
 with "abca".
 |"hello".| Create a new automaton that is tiled with the string "hello".
==External resources==
* 
Category:Languages
Category:Unimplemented
Category:Unknown year
Category:Meta-languages
OFC

One Function Code is a one-instruction attempted turing-tarpit invented by User:A. Its only command is:
 [x]=content of register x
 if(r,a,b)
 If[#r]==0,goto line a.Else,flip[#r] and goto line b.
==Computational Class==
OFC has only finitely many bits of memory, which can only be set from 1 to 0 (a 0 bit cannot be flipped to 1). As such, if memory is initialised to all-zeroes, it devolves into a sequence of goto statements; and even if memory is allowed to be initialised differently, there's a finite cap on how long any given program can run.
Category:Languages
Category:Unusable for programming
OFFICIAL

OFFICIAL is a esolang created by User:Yayimhere. thats it
== how it works ==
OFFICIAL has these commands:
 >v#
 ^<]$
the arrows are obvious but heres what the # is. lets say we have a pointer(represented by !). heres what happens:
 #
 !
iter 1:
 #
 !
iter 2:
 #
 !
iter 3:
 !#
iter 4:
 ! #
the pointer comes in from one direction the it moves the #. it moves the # clockwise. if the # comes in front of it it turns 180 degrees. and you will also ask what the ] command does. well it will just be pushed in pointer direction. and if its pushed into another symbol the program halts. and $ will skip the command in pointer direction. also the grid is infinite in downwards and rightwards direction and the pointer is at the top left corner of the grid 
== examples ==
loop:
v<
>^
double cycle:
 v #
 > $# $ <
Category:Languages Category:Two-dimensional languages Category:No IO
OHE

OHE is an esolang created by User:ResU in 2021. Every program prints "Hello, world!".
==Examples==
===Hello, world!===
===Quine===
Hello, world!
===Implementations===
The following provides a simple implementation in Common Lisp:
 (defun interpret-OHE (&optional (code ""))
 "Interprets the OHE CODE and returns NIL."
 (declare (type string code) (ignore code))
 (format T "~&Hello, world!"))
Category:Joke languagesCategory:Output onlyCategory:Unusable for programmingCategory:2021Category:ImplementedCategory:LanguagesCategory:Total
ONABOBFE4P

:Oh no, Another Bunch Of BrainF*ck Emulators For Python?
ONABOBFE4P, which stands of "Oh no, Another Bunch Of BrainF*ck Emulators For Python" (github link), created by User:Eso-t. It is a Python Library to create/use interpreters of the brainfuck language, intended for flexility and customization. The library not only allows an array of configurations (such as maximum value size, rollback behaviour, etc.) but it also includes hooks so that anyone can add further functionality to it.
Currently the library has 4 brainfuck interpreter designed: vainilla, verbose, quantum and curses. 
* Vainilla: simply runs the code
* Verbose: runs the code, printing the memory status and pointers once every 100 instructions
* Quantum: gives quantum to each action. (to allow a faux "hardware" emulation)
* Curses: uses curse to provide the user with information of the immediate program and data stacks. It can additionaly change speeds, going from completely halted to max_speed. (the image attached on this page is the Curses interpeter running inside PyCharm)
All 4 were created as 8-bits no-rollback interpreters, but that can be easily changed by changed the initialization variables of the interpreters)
Category:Brainfuck Category:Implementations Category:Implemented
ONLY 4 COMMANDS

Just like Ａｅｓｔｈｅｔｉｃｓ but more clearly.
== Commands ==
 Command Table
ONLY 4 COMMANDS 	Aesthetics(I only use the Character Map to enter double-width characters, but that would be too cumbersome, so I'm using half-width characters here.)	HQ9+
Print "Hello, world!" to screen. 	リサフランク420 / 現代のコンピュー! 	H
Print the lyrics to 99 bottles of beer. 	Ａｅｓｔｈｅｔｉｃｓ 	9
Print the source code of this program. 	ＭＡＣＩＮＴＯＳＨ　ＰＬＵＳ 	Q
Oh, there is a hidden accumulator, this command increase it.	蒸気波 	+
== Example ==
Ditto. I don't want to fucking write it anymore. It's useless to write. (So there are 3 programs.)
== Categories ==
Category:Languages
ON THE WAY TO WHO KNOWS WHERE

==Commands==
Alphabet numbers	controls
1 	input a string and push it onto the stack
2 	clear the next word.
3 	clear the whole program 3 words after the word
4 	pop the stack.
5 	Push "Hello,world"
6 	Undefined behavior(Maybe the computer will burn itself)
7 	Start changing the syntax around randomly-Maybe you can naver use it when this command is used
8 	Go down 3 lines.
9 	Go up 3 lines.
11 	print "Hello,world"
It pops the stack and prints a string at the end.
==Hello,world==
 ON THE WAY TO WHO KNOWS WHERE
or:
 Hello,world
or:
 HEY!!
Category:Languages
Category:Stack-based
Category:Unimplemented
OOOOL

OOOOL is the acronym for "Object-Oriented Output Only Language". It is invented by User:A.
==Tutorial==
===How to define a function===
To define a function, you make it like this:
 FUNC:
 (do someting)
===How to define a class===
To define a class, you make it like this:
 Class:
 Func:
 (do comething)
===How to output===
To output, you make it like this:
 (Output string)
Category:Object-oriented paradigm
Category:Output only
Category:Languages
OOTPL

== Introduction ==
OOTPL (Only One Token Per Line), created by Noedig101 (talk) 18:24, 4 March 2024 (UTC), has the exact same syntax as Python. However, you can only have one token or value per line. If more than one token or value appears on the same line, a syntax error will be given. Line continuation is necessary for certain commands. Any braces or mathematical operators must be at the end of a line and must have at least three spaces between them and the token or value on that line. It is recommended that these are placed in the same position vertically for readability.
=== Instructions ===
Most commands in Python can be achieved without line continuation, such as the print command.
 print (
 "Hello World!" )
Some commands, like variable assignment and if/else statements, must be done using line continuation with \.
 var =\
 "value"
 
 if \
 var ==\
 "value" \
 or \
 True :
 print (
 "Hello World" )
 else :
 print (
 "Example" )
Lists can be done like so:
 lst =[
 1 ,
 "Hi" ,
 None ,[
 "no" ,
 -3 ,]
 True ]
Commands with multiple arguments also work the same way.
 functionName (
 arg1 ,
 arg2 ,
 arg3 )
Importing modules would work like this:
 import \
 moduleName
 
 from \
 random \
 import \
 randint
=== Examples ===
Hello World!
 print (
 "Hello World" )
Prints input.
 print (
 input ())
99 bottles of beer.
 a =\
 99
 while \
 a >=\
 0 :
 if \
 a >\
 0 :
 print (
 str (
 a )+\
 " bottles of beer on the wall," )
 print (
 str (
 a )+\
 " bottles of beer!" )
 print (
 "Take one down, pass it around," )
 if \
 a ==\
 1 :
 print (
 "No more bottles of beer on the wall." )
 else :
 print (
 str (
 a -\
 1 )+\
 " bottles of beer on the wall." )
 a -=\
 1
 else :
 print (
 "No more bottles of beer on the wall," )
 print (
 "No more bottles of beer!" )
 print (
 "Go to the store and buy some more," )
 print (
 "99 bottles of beer on the wall!" )
Note: this is my first esolang article, and will probably have some mistakes. If you have any questions email me at noedig101@gmail.com
Category:Languages Category:High-level Category:Turing complete Category:Esoteric subset
OR

OR (One Register) is an esolang by User:ChuckEsoteric08 derived from 1-register Minsky machine
==Specification==
A language has a single register, initialised to one, and a constant, initialised to 0
 Commands
Command	Description
> 	set constant to the amount of >'s. Example >>> sets the constant to 3
* 	Multiply register by a constant
/x 	Tries to divide register by a constant, if it fails then it would jump to 1-indexed instruction x, which is encoded as a string of <'s, if it succesful then divide register by a constant and execute next instruction. Example: /<<< would jump to third instruction if it is not divisible by a constant
==Computational class==
The language is Turing-complete, as it can implement Minsky machine:
Each register is encoded as prime factors in a register, so the value 2a3b5c refers to three registers a, b and c
To increment a register you need to multiply a register by a prime number for that register:
 > p-times, *
To decrement it we need to divide instead
 > p-times, /x
Category:Languages Category:Turing complete Category:Turing tarpits Category:Unimplemented
OREO Conversion Sheet

The OREO conversion sheet (by User:Yes and User:Europe2048)
 Conversions
Language 	RE 	O 	&O
OREO 	RE 	O 	&O
brainf*** 	+ 	> 	.
Minimalbf 	+ 	0 	.
Bitcoin (assuming the price of bitcoin is $1.00)	sell 	next 	brag
Deadfish 	i 	(number of d's until 0) 	o
this 	red GOES UP 	(number of red GOES DOWN's until 0)	red CAN VOUCH GO AND TELL THEM COME ON
Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee 	Infect person	Bulk deinfectDeinfect person 	Check number of infections
+-= 	+ 	(Number of - until 0) 	=
Eso2D 	+ 	} 	#
Deadfish++ 	i 	0 	o
More will be added in the future
If you wish to contribute to the list, please confirm the conversion actually works.
Do NOT delete any conversions unless they are proven to be incorrect.
ORK

ORK (Objekts R Kool), designed by Gregor Richards in 2005, is an object-oriented language that has a very verbose syntax, unlike most other esoteric programming languages. It's object oriented to such a degree, that even simple operations (addition, subtraction, comparisons) require the instantiation of an object. According to the spec, its divine purpose in existance is to be the polar opposite of Brainfuck.
==Examples==
===Hello, world!===
 When this program starts:
 There is a scribe called Writer.
 Writer is to write "Hello, world!"
===Cat===
(in the spirit of the language this program is excessively verbose)
 There is such a thing as a mouse.
 A mouse can be_eaten.
 A mouse has a status which is a word.
 A mouse has a voice which is a scribe.
 A mouse has an input which is an inputter.
 
 When a mouse is to be_eaten:
 There is a word called squeaky sound.
 input is to readOne squeaky sound.
 If input says it's done then status is "eaten".
 voice is to write squeaky sound.
 
 There is such a thing as a cat.
 A cat can eat a mouse.
 A cat has a Lingo which is a linguist
 
 When a cat is to eat a mouse:
 The mouse is to be_eaten.
 Lingo's first operand is the mouse's status.
 Lingo's second operand is "eaten".
 Lingo is to compare.
 If Lingo says it's not equal then I am to loop.
 
 When this program starts:
 There is a cat called Lucifer Sam.
 There is a mouse called Gerald.
 Gerald's status is "alive".
 Lucifer Sam is to eat Gerald.
===One Time Cat===
Being as succinct as possible, against the spirit of the language.
When this program starts:
There is a word called x.
There is an inputter called y.
There is a scribe called z.
y is to readOne x.
z is to write x.
===Truth Machine===
There is such a thing as a truth machine.
When a truth machine is to zero:
There is a scribe called z.
z is to write 0.
When a truth machine is to one:
There is a scribe called z.
z is to write 1.
I am to loop
When a truth machine is to run a word:
There is a linguist called l.
l's first operand is the word.
l's second operand is "0".
l is to compare.
If l says it's equal then I am to zero
If l says it's not equal then I am to one
When this program starts:
There is a word called x.
There is an inputter called y.
y is to readOne x.
There is a truth machine called t.
t is to run x.
==External resources==
* ORK Homepage 
* ORK in the Esoteric File Archive
* Online ORK interpreter in JavaScript and a more complete specification of ORK by Pedro Gimeno Fortea
Category:Languages
Category:Object-oriented paradigm
Category:Turing complete
Category:Implemented
Category:High-level
Category:2005
Category:Pseudonatural
OZZo

Created by User:Fly, oZZo (that stands for "one zero zero one" or "1001") is an esoteric programming language that uses instructions made of binary numbers.
==Instructions==
Command	Description
1111 	sets memory to true
0000 	sets memory to false
1001 	print memory
1110 	input
1010 	save input in memory
1101 	clear memory
0101 	sets errorlevel to 1
1011 	sets errorlevel to 0 (by default is zero)
0100 	checks if errorlevel is 1 than goes to the next instruction
0110 	checks if errorlevel is 0 than goes to the next instruction
0111 	break
==Exemple programs==
===Hello World===
111010101001
Input: !dlroW ,olleH (yes it has to be backwards since binary numbers are read backwards, the input will be backwards too)
Output: Hello, World!
==Computational Class==
I have to say that this language is not turing complete, since the language memory is based on only one variable in the intepreter, and even if the memory was infinite or based on an array it still wouldn't be turing complete.
==Implementation==
import textwrap
memory = ""
inp = ""
errorlevel = 0
code = input()
# 1111 = sets memory to true
# 0000 = sets memory to false
# 1001 = print memory
# 1110 = input
# 1010 = save input in memory
# 1101 = clear memory
# 0101 = set errorlevel to 1
# 1011 = set errorlevel to 0
# 0100 = check if errorlevel is 1 than go to the next instruction
# 0110 = check if errorlevel is 0 than go to the next instruction
# 0111 = stops the program
instructions = textwrap.wrap(code,4)
for part in instructions:
	if part == "1110":
		inp = input()
	elif part == "1010":
		memory = inp
	elif part == "1001":
		print(memory[::-1])
	elif part == "1101":
		memory = ""
	elif part == "0101":
		errorlevel = 1
	elif part == "1011":
		errorlevel = 0
	elif part == "0111":
		break
	elif part == "0100":
		if errorlevel == 1:
			if instructions[instructions.index(part)+1] == "1110":
				inp = input()
			if instructions[instructions.index(part)+1] == "1010":
				memory = inp
			if instructions[instructions.index(part)+1] == "1001":
				print(memory[::-1])
			if instructions[instructions.index(part)+1] == "1101":
				memory = ""
			if instructions[instructions.index(part)+1] == "0111":
				break
			if instructions[instructions.index(part)+1] == "1111":
				memory = "eurt"
			if instructions[instructions.index(part)+1] == "0000":
				memory = "eslaf"
	elif part == "0110":
		if errorlevel == 0:
			if instructions[instructions.index(part)+1] == "1110":
				inp = input()
			if instructions[instructions.index(part)+1] == "1010":
				memory = inp
			if instructions[instructions.index(part)+1] == "1001":
				print(memory[::-1])
			if instructions[instructions.index(part)+1] == "1101":
				memory = ""
			if instructions[instructions.index(part)+1] == "0111":
				break
			if instructions[instructions.index(part)+1] == "1111":
				memory = "eurt"
			if instructions[instructions.index(part)+1] == "0000":
				memory = "eslaf"
	elif part == "1111":
		memory = "eurt"
	elif part == "0000":
		memory = "eslaf"
Category:Languages Category:2023 Category:Implemented
Obfuck

Obfuck is a brainfuck equivalent.
==Syntax==
First, translate the brainfuck into binaryfuck.
Then, translate it to a decimal number.
Next, add some nonnumeric chars between each digit.
Next, add one character between each character.
Next, convert them into UTF-8 and write it in binary.
Next, reverse it.
finally, take 3 bits a group and translate them according to the following:
bits	text
000 	l
001 	I
010 	1
011 	
100 	∣
101 	Ι
110 	ι
111 	Í
line wraps are ignored.
==Examples==
I did them in python.
===Hello world===
 1|IιÍI1ι∣|ΙlιlΙιιΙ∣∣Í|lιΙIΙ1Í|Ιι1|IlÍI1ιI|∣∣ιIIιlÍ
 Ι1|lΙ∣Í|Ι∣Í1IιÍI∣1Í1I∣1|∣ιι1∣ι∣ΙΙιÍ1Ι∣∣|∣||lΙιι|l∣
 ÍIΙ∣ΙIΙlι|ΙιlÍΙlÍ1Ι∣I|∣∣ÍIIιI|Ι1||I∣Í|Ι1Í1IιI|l1ÍI
 Ι∣1|ΙΙ|1∣ι∣ÍIιÍl|∣∣|∣1ÍlΙιι|l∣ÍlΙ∣ΙI∣IÍ|ΙιlÍIlÍI∣ι
 I|Ι1ιIIιι|I1|l1ιÍ|ΙIι1IιιΙ∣1Í|I∣1|∣Ι|1∣ιlÍIιÍ1I∣∣|
 ∣||lΙι∣Íl∣Íl|∣ΙIΙ∣ι|ΙιÍ|ΙlÍl|∣I|Ι1|IIιlÍI1|IIιÍ|∣I
 ι1Iι∣Íl1Í|Ι∣1|∣I|1∣ι∣ΙΙιÍII∣∣|∣Ι|lΙιlΙ∣∣Í|Ι∣ΙIΙIι|
 ΙιI|ΙlÍl|ιI|∣1ιIIι∣|I1|l|∣Í|Ι∣Í1IιI|∣1ÍII∣1|∣1|1∣ι
 I|IιÍ|∣ι∣|∣∣ιlΙιlΙ∣∣ÍlI∣ΙIΙιι|Ιιι|ΙlÍ1∣ιI|∣I|IIιI|
 I1|IΙ∣Í|Ι∣ι1IιlÍ∣1Í|I∣1|∣Iι1∣ιI|IιÍ1|∣∣|∣∣ÍlΙι∣Í∣∣
 Íl1ιΙIΙιι|Ιι∣ÍΙlÍ1I∣I|∣ι|IIιlÍI1|l1ιÍ|∣∣ι1Iιl|l1Íl
 ∣ι1|∣Ι|1∣ιι|IιÍ1|ι∣|∣ιιlΙιlÍl∣Í|I∣ΙI∣∣ι|Ιι|IΙlÍlΙ∣
 I|Ι1ιIIιI|Ι1|1I∣Í|∣∣Í1Iι∣|I1Ι1Ι1
Category:2024Category:Turing completeCategory:Brainfuck derivativesCategory:Languages
Obfunge

Obfunge is a Befunge-93 derivative invented by User:None1, it is Befunge-93 but obfuscated.
==Instructions==
Befunge-93 has the following commands:
Cmd 	Description
! 	Addition: Pop two values a and b, then push the result of a+b
" 	Subtraction: Pop two values a and b, then push the result of b-a
# 	Multiplication: Pop two values a and b, then push the result of a*b
$ 	Integer division: Pop two values a and b, then push the result of b/a, rounded down. According to the specifications, if a is zero, ask the user what result they want.
% 	Modulo: Pop two values a and b, then push the remainder of the integer division of b/a.
& 	Logical NOT: Pop a value. If the value is zero, push 1; otherwise, push zero.
' 	Greater than: Pop two values a and b, then push 1 if b>a, otherwise zero.
( 	PC direction right
) 	PC direction left
* 	PC direction up
PC direction down 	
, 	Random PC direction
Horizontal IF: pop a value; set direction to right if value=0, set to left otherwise	
. 	Vertical IF: pop a value; set direction to down if value=0, set to up otherwise
/ 	Toggle stringmode (push each character's ASCII value all the way up to the next /)
0 	Duplicate top stack value
1 	Swap top stack values
2 	Pop top of stack and discard
3 	Pop top of stack and output as integer
4 	Pop top of stack and output as ASCII character
5 	Bridge: jump over next command in the current direction of the current PC
6 	A "get" call (a way to retrieve data in storage). Pop two values y and x, then push the ASCII value of the character at that position in the program. If (x,y) is out of bounds, push 0
7 	A "put" call (a way to store a value for later use). Pop three values y, x and v, then change the character at the position (x,y) in the program to the character with ASCII value v
8 	Get integer from user and push it
9 	Get character from user and push it
: 	End program
;<=>?@ABCD 	Equivalent to Befunge-93's 0 to 9
Do you think that's all? No! The program must be decrypted first!
Encryption is done using the following method:
e[i][j]=(a[i][j]+3*a[i][j-1]+5*a[i-1][j]-7*a[i-1][j-1])%94
Where e[i][j] stands for the encrypted character, a[i][j] stands for the original character, using this encoding:
 (space)!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
Decryption can be done like this:
 a[i][j]=(e[i][j]-3*a[i][j-1]-5*a[i-1][j]+7*a[i-1][j-1])%94
Category:Languages
Category:2025
Category:Two-dimensional languages
ObfuscatedFuck

ObfuscatedFuck is a brainfuck equivalent.
The program is a list of tokens, each representing a bit string. By concatenating all these tokens together, you get a bitstring that can be turned into brainfuck.
The tokens are:
 Tokens
token	meaning
o 	0
0 	0
O 	0
1 	1
I 	1
\ 	1
/ 	1
 	1
8 	00
d 	01
q 	01
b 	10
p 	10
P 	10
% 	010
The resulting bitstring the can be translated into brainfuck.
 Mapping
BF 	ObfuscatedFuck
000	+
001	-
010	<
011	>
100	.
101	,
110	[
111	]
== Examples ==
===Hello World===
 8o8o8o8o8o8o8o8o1bd18o8o8o8o1bd18o8od18o8o8od18o8o8od18o%%%%81111d18od18od181d1d18o1b%111%81111d1d1bod1818181bo8o8o8o8o8o8o8obobo8o8o8obod1d1bo%81bo%bo8o8o8obo818181818181bo8181818181818181bod1d18obod18o8obo
===Cat Program===
A repeating cat program follows, the same terminates on a user input of the null character:
 1d1bbo1d111
===Truth-Machine===
This program furnishes a truth-machine:
 1dbo1b8181d18o1bd1d1111%1bbo111%%111
==Interpreter==
* Common Lisp implementation of the ObfuscatedFuck programming language.
Category:Brainfuck equivalents
Category:Languages
Category:2023
Category:Implemented