nyuuzyou/wikis huggingface dataset:
One-Instruction Cyclic Tag

One-Instruction Cyclic Tag (OICT) is an esoteric language for programming cyclic tag systems using just a single instruction. OICT is inspired by Bitwise Cyclic Tag and its alphabet is also composed solely of two symbols: 0 and 1.
All symbols other than 0 and 1, including whitespace, are ignored as comments.
OICT is Turing complete, as it can directly simulate any cyclic tag system, which has been proven to be universal.
== Instruction TAG ==
The only instruction, TAG, used to define a production takes two arguments and has the following form:
1[1×n]0[(0|1)×n)]
Where n is a non-negative integer.
* The first argument, represented by the sequence of 1s following the initial 1, defines the length of the production.
* The second argument, the sequence of 0s and 1s following the first 0 in the instruction, represents the production string.
== Examples ==
Whitespaces are added for readability.
Production (101):
 1 111 0 101
Productions (011, 10, 101):
 1 111 0 011
 1 11 0 10
 1 111 0 101
Productions (1, ε, 0):
 1 1 0 1
 1 0
 1 1 0 0
== Debugging ==
Optionally, an interpreter might implement an additional DEBUG instruction, denoted by ;, which provides information about the current execution status, such as the current word and the computation step.
DEBUG is not a computation instruction, therefore it won't increase the step counter.
Example:
 ;11110011;111010;11110101
Initial word 1
Outputs (step: word)
0: 1, 1: 011, 2: 11, 3: 1101, 4: 101011, ...
== External resources==
* An interpreter in JavaScript
Category:Languages Category:Turing complete Category:Turing tarpits Category:Queue-based Category:No IO Category:Implemented Category:2024 Category:OISC
OneFuck

OneFuck, is an esoteric programming language clones brainfuck, buts here only one cell.
== Examples ==
=== Hello, world! ===
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++.!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
+++++++++++++++++++++++++++++++++.!
++++++++++.!
=== Output input symbol ===
,.
== Added instructions ==
Name	Desc
! 	Clear cell
` 	Output cell value as integer
== External resources ==
* https://github.com/SLNETAIGA/OneFuck (Implement on PHP)
* http://alc.comuf.com/MCSBL/OneFuck.m (Implement on MCSBL, nested loops not implemented!)
* http://alc.comuf.com/OneFuck.jake (Implement on Jake(jakelang.sourceforge.io) programming language, nested loops not implemented!)
Category:Languages
Category:2016
Category:Brainfuck
Category:Unusable_for_programming
Category:Implemented
OneLine

OneLine is a no-longer worked on eso-lang made by User:Zenenbee that is based off of Brainfuck.
==Commands==
Command	Description
$text$ 	Prints text
^ 	Increases the count by 1
_ 	Decreases the count by 1
~ 	Prints the count as integer
! 	Starts or ends a loop, goes past loop if the count == 0
==Examples==
===Hello, World!===
 $Hello world$
===Infinite loop===
 ^!!
==External resources==
===Interpreters in Python===
* OneLine is the main interpreter created by User:Zenenbee
Category:Languages Category:Implemented Category:Unknown computational class Category:2020
One (Tailcalled)

One is a language invented by User:Tailcalled. It is an uncomputable extension to a Brainfuck dialect, but it is designed to not be significantly more powerful than ordinary Brainfuck.
One has nine instructions, eight of which are similar to brainfuck. The syntax rules are the same as in Brainfuck. In addition to the memory pointer, there is an internal counter, C.
Instruction 	Description 	Name
Increment 	Increments the value pointed to. There is no maximal value. 	+
Decrement 	Decrements the value pointed to. There is no minimal value. 	-
Next 	Increments the pointer. There is no maximal index. 	>
Previous 	Decrements the pointer. There is no minimal index. 	<
Loop (begin)	Loops the body while the value pointed to is not zero. 	[
Loop (end) 	Loops the body while the value pointed to is not zero. 	]
Output 	Outputs the value pointed to as a unicode codepoint if valid; otherwise noops. 	.
Input 	Inputs a unicode codepoint and stores it as the value pointed to. Stores zero on EOF. 	,
Instruction 	Consider the Busy Beaver function for Brainfuck. Let x be the value pointed to. Instruction stores the xth bit of the Cth Busy Beaver number as the value pointed to, followed by incrementing C. Stores zero on negative input, as the fractional part of any Busy Beaver number is zero.	I
Intuitively, Instruction seems hard to compute and not very useful. It is not immediately obvious how to prove those statements.
== Busy Beaver ==
Since the Busy Beaver function is not completely unambiguous, I will define exactly what it is here. When I talk about Brainfuck, I am referring to One, without Instruction and without comments.
Consider Brainfuck, but augmented with a hidden counter C and an instruction for incrementing C, which I will call J, a shortening of Jnstruction. Call this language Jrainfuck. The time of an ordinary Brainfuck program P is the final value of C given running P as a Jrainfuck program with the following modifications:
# A J is inserted before every character.
# Every , is replaced by [-].
If the program does not halt, the time is said to be 0.
Busy beaver of x is then given by the maximal time of a program of at most x length. In particular, BB(0) is 0, as only the empty program has zero length. BB(1) is 1, as any 1-length program executes the same amount of instructions. Note that the time of [] is 1. The time of -, is zero, as it does not halt after the modification.
Category:Languages Category:Cell-based Category:Uncomputable Category:Brainfuck derivatives Category:Unimplemented Category:Turing complete Category:2014
One Time Cat

A One Time Cat program is the same as a normal Cat program, but then working with only 1 character. The program form was created by User:DanielE.
Since it accepts one character, it is easier than a Cat program.
== Examples ==
=== Python 3 ===
 print(__import__('sys').stdin.read(1))
=== brainfuck ===
 ,.
=== ><> ===
 io;
=== Befunge-93 ===
 ~,@
=== Shakespeare ===
The One-Time Cat.
Romeo, the commander.
Juliet, the obeyer.
 Act I: Le Program.
 Scene I: The copying of the user.
[Enter Juliet and Romeo]
Romeo:
 Open your mind.
 Speak your mind!
[Exeunt]
===C===
 main(){putchar(getchar());}
===ORK===
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.
===Sakana===
読書
===$+-?===
==See also==
* Cat program
Category:Program forms
Onecode (Fergusq)

Onecode is a programming language created by User:Fergusq as a part of his Twocode programming language.
== Statements ==
Onecode (one-dimensional code) is used as the one-dimensional part of Twocode. Pure onecode doesn't have any control structures as they must be implemented by the parent language. The "stand-alone" version of Onecode uses GOTO statements.
== Syntax ==
=== Grammar ===
 stmt := <expr> {";" <expr>}
 expr := <logic>
 logic := <cond> {("&"|"|"|"^") <cond>}
 cond := <add> {("="|"<"|">") <add>}
 add := <mul> {("+"|"-") <mul>}
 mul := <prim> {("*"|"/") <prim>}
 prim := "*" <prim_t> ["~" <expr>] | <var> ["~" <expr>] | <prim_t>
 prim_t := "(" <expr> ")" | "*" <prim_t> | "!" <prim> | <function_call> | <value>
 function_call := "getc" "(" ")" | "getn" "(" ")" | "putc" "(" <expr> ")" | "putn" "(" <expr> ")"
 value := <number> | <var> | "'" <chr> "'" | <string> | "[" [<value> {"," <value>}] "]"
=== Operators ===
Precedence	Operator	Description 	Associativity
1 	* 	Indirection (Unary)	Right-to-left
1 	! 	Logical NOT (Unary)	Right-to-left
1 	- 	Unary minus 	Right-to-left
2 	* 	Multiplication 	Left-to-right
2 	/ 	Division 	Left-to-right
3 	+ 	Addition 	Left-to-right
3 	- 	Subtraction 	Left-to-right
4 	= 	Equal 	Left-to-right
4 	< 	Less than 	Left-to-right
4 	> 	Greater than 	Left-to-right
5 	& 	Logical AND 	Left-to-right
5 	 	Logical OR 	Left-to-right
5 	^ 	Logical XOR 	Left-to-right
6 	~ 	Assigment 	Right-to-left
=== Assigments ===
In addition to a normal expression, rvalue may be a list or a string.
Lists are groups of expressions. They are used to change many memory slots at the same time.
 i~2; // Memory : [0,0,0,0,0,0,0,...]
 *i~[1,2,3]; // Memory : [0,0,1,2,3,0,0,...]
Strings are similar to list, but contain the null terminator automatically:
 s~2;
 *s~"Hi!"; // Memory: [0,0,'H','i','!',0,0,...]
=== Statements ===
The only statement in Onecode is the expression statement. In addition to that the stand-alone version provides following statements:
# Label statement: label_name:
# Goto statement: goto label_name;
# If statement: if (expr) goto label_name;
Sometimes else-keyword is used after the if statement, but it is not required.
== Computational class ==
Computational class depends on the parent language. The stand-alone version and Twocode are Turing complete.
== Examples ==
=== Hello world ===
 s~0;
 *s~"Hello, world\n";
 print:
 putc(*s);
 s~s+1;
 if (*s) goto print;
=== Truth-machine ===
 i~getc();
 if (i='1') goto truth;
 if (i='0') goto lie;
 goto other;
 truth:
 putc(i);
 goto truth;
 lie:
 putc(i);
 other:
Category:LanguagesCategory:Low-levelCategory:Turing completeCategory:2014
Onecode (Iconmaster)

Onecode is an idea for a language made by User:iconmaster. Onecode's major goal is to use every Unicode character in its commands. It currently is including an accumulator, and as many data types as possible.
== Description ==
There is an array of 65536 variables (one for each Unicode character). One of these variables (Ä) is designated as the Accumulator, or ACC for short. Another variable (Ŝ) is called the Default Stack, or DSTK. the variables in the characters 0 through 9 hold zero through nine, respectively, and the characters at 0xE000 through 0xEFFF hold 0x000 through 0xFFF.
There are 4 data types so far: number, string, list, and function. Stacks are actually represented by lists.
Each command is one character long, but may have arguments that immediatly precede it.
== Commands ==
In no real order as of now.
* " all the characters between two "s are put into ACC as a string.
* ' all the characters between two "s are put into ACC as a number.
* ( ) loop forever bewteen ().
* [ ] loops between [] while ACC equals zero.
* { } loops between {} while ACC does not equal zero.
* ~ (1 arg) the character arg1 as a string -> ACC.
* < (1 arg) arg1 -> ACC
* > (1 arg) ACC -> arg1
* +,-,*,/,% (2 args) arg1 (+,-,*,/, or %) arg2 -> ACC
* : all the characters between two :s are put into ACC as a function.
Category:Ideas
Oneline

Oneline is an object-oriented stack-based esoteric programing language designed to be as compressed as possible.
==Instructions==
Character 	Function
{ 	Starts a class
} 	Ends a class
[ 	Starts a function
] 	Ends a function
( 	Starts a codeblock
) 	Ends a codeblock
:identifier 	Pops a value and saves it in a property
instance%property	Pushes the property's value. If the instance is ommited, it will be refered to this intance
_ 	While loop
? 	If
, 	Else
# 	Number
@t/@f 	True/False
+ 	Pop two numbers and add them together, or pop two characters and combine them to form a string
- 	Pop two numbers and substract them together
* 	Pop two numbers and multiply them together
/ 	Pop two numbers and divide them together
$ 	Pop a number and push and character with that ASCII code
O 	Pop a value and print it
I 	Read a value from the user input and push it
==Syntax==
* Create function:
 [statements]
* Create a property:
 value:identifier
* Create a class:
 identifier{[main-function][other-function][other-function]}
* Create an instance of a class:
 !indentifier
* Acces a property of an instance:
 instance%property
* Acces a method of an instance (the # is there because the method index is a number):
 instance#method-index
Category:Languages Category:Unimplemented Category:Object-oriented paradigm Category:Stack-based Category:2019
Oneliner

Oneliner is a esoteric programming language, where every program is supposed to have only one line. Every program with more than 1 line has a one-line version. Newlines are not ignored.
== Overview ==
Oneliner is based on 3 objects: C, c and V. C (stands for Code) is the main object. It can execute code and store variables. c (stands for code) is a predefined Code object. V (stands for Value) is a non-constant value.
Oneliner uses the build technique, where blocks are added one-by-one and then executed at the same time.
== Syntax ==
Here's how to write programs using Oneliner:
Code 	Description 	Pseudo-code
C() 	Initialize a new Code object 	Code()
c() 	Get variable enviroment 	code.variables
c()["varname"] or c["varname"] 	Get the value of a variable 	varname
c()["varname",123] 	Set the value of a variable 	varname = 123
c().g("varname") 	The function version of c()[...] 	varname
c().s("varname",123) 	The function version of c()[..., ...] 	varname = 123
c()() 	Go back to Code 	code.variables.code
c[function,(1,2,3),{"a":45}] 	Add a block 	code.addBlock(function(1, 2, 3, a=4))
c(1) 	Execute all blocks and clear the build 	code.executeBlocks(clear=True)
c.lr 	The return value from the latest executed block 	code.lastReturn
c.glr() 	The function version of c.lr 	code.getLastReturn()
c.b() 	Execute all blocks without clearing the build 	code.executeBlock(clear=False)
c.c() 	Clear the build 	code.blocks = []
c.f() 	Create a function copy of the Code object with fixed blocks	code.asFunction()
c.i(C()[boolean,(1,),{}].f(),print,("Test",),{}) 	Add an if statement to the build 	code.addBlock( if(boolean(1)) { print("Test") } )
c.ii(...) 	Run an if statement without adding it to the build 	if(boolean(1)) { print("Test") }
c.ie(C()[boolean,(1,),{}].f(),print,exit,(1,),{})	Add an if-else statement to the build 	code.addBlock( if(boolean(1)) { print(1) } else { exit(1) } )
c.iie(...) 	Run an if-else statement without adding it to the build 	if(boolean(1)) { print(1) } else { exit(1) }
The rest will be added soon.
== Examples ==
=== Hello, World! ===
Here's a simple one:
 c[print,("Hello, World!",),{}](1)
Explanation:
 c[ Add a block to the build
 print, The function to be called
 ("Hello, World!",), Positional arguments
 {} Keyword arguments
 ] Block end
 (1) Execute and clear the build
=== Truth-machine ===
Oneliner:
 c()["i",num(input())]()[print,("1",),{}].ie(C()[boolean,(c["i"])].f(),c.b,c.c,(),{}).iie(C()[boolean,(c["i"])].f(),c.b,c.c,(),{})
Explanation:
 1) Input is saved to i as a number: c()["i",num(input())]
 2) Print 1 is added to the build: ()[print,("1",),{}]
 3) Continue the loop by executing the build if i is 1: .ie(C()[boolean,(c["i"])].f(),c.b,c.c,(),{})
 4) Start the loop with an instant if-else: .iie(C()[boolean,(c["i"])].f(),c.b,c.c,(),{})
== Note ==
This article is about 30 or so percent done. It will be updated later.
:Feel free to edit this article.
Category:2024 Category:Turing complete Category:Works-in-Progress
Onesharp

Onesharp (or 1#) is a minimalistic programming language created as a teaching tool by Larry Moss.Moss, Lawrence S. "Invitation to Computability." lmoss.github.io. It operates on a register machine model, in which instructions can modify registers or control program flow. The language features five fundamental operations: appending 1 or # to a register, jumping forward or backward by a specified number of instructions, and a conditional branching mechanism that removes and examines the first character in a register. Onesharp programs consist entirely of sequences of 1's and #'s.
==Syntax==
 Onesharp (1#) Instruction Set
Instruction	Meaning
1ⁿ# 	Append 1 to register n.
1ⁿ## 	Append # to register n.
1ⁿ### 	Move forward n instructions.
1ⁿ#### 	Move backward n instructions.
1ⁿ##### 	Conditional branching on register n: 
* If empty, move to the next instruction. 
* If the first character is 1, delete it and move forward two lines. 
* If the first character is #, delete it and move forward three lines.
==Purpose==
Onesharp is introduced through an interactive Jupyter notebook tutorial, which includes an interpreter and step-by-step execution tools written in Python. Users are guided through small programs and exercises demonstrating basic operations. The notebook also provides command-line tools for parsing and running onesharp programs. Moss then uses onesharp to define computability and demonstrate several fundamental results of computability theory.
==References==
Ontology

ontology is a esolang created by User:Yayimhere based on ontology.
== how it works ==
the code is set up like this:
 ----------------
 code
 ----------------
 matrix
 ----------------
and a matrix is made like this:
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
each cell([ ]) can hold a single symbol. this is the basic syntax:
 [x]{y|
this states that if there is a cell containing x will then do code y. this is what y can be:
 y
command	description
[x! 	x does not exist. this means that all cells holding x will be deleted
[xy:z 	x AND y is z. each cell thats holds x and has a neighbour y will replace that with a single cell holding z
¬[x]! 	the only thing that exists is x. deletes every cell thats not x
x} 	x exists. append x to the matrix
the matrix will always simplify like this:
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
becomes:
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x][x]
 [x][x][x][x][x][x][x]
the code section loops until only one thing exists
Oof

Oof (Not to be confused with Oof!) is an esoteric programming language designed by User:Nirex0. Because every command in Oof can be represented with the same amount of brainfuck commands, it can be considered a TrivialBrainfuckSubstitution.
== How it works ==
Much Like BrainFuck, in oof, you are in control of a single pointer, and you use commands to control that pointer, commands are created using a series of "o"s followed by a single "f"
Let's call the number of "o"s in your string OLen
== Language Structure ==
=== Rules of OLen: ===
# (OLen % 8 + 1) determines what your command will do
# (OLen / 8) determines how many times your command will execute
=== Commands ===
Brainfuck	Shortest equivalent in Oof	Formula
> 	f 	(OLen%8+1)=1
< 	of 	(OLen%8+1)=2
+ 	oof 	(OLen%8+1)=3
- 	ooof 	(OLen%8+1)=4
. 	oooof 	(OLen%8+1)=5
, 	ooooof 	(OLen%8+1)=6
[ 	oooooof 	(OLen%8+1)=7
] 	ooooooof 	(OLen%8+1)=8
=== Interpreter ===
You can download the interpreter's source code here!
Category:Implemented
Category:Brainfuck equivalents
Category:Joke languages
Category:Cell-based
Category:Turing complete
Category:Low-level
Category:2019
Category:Languages
Category:Brainfuck derivatives
Category:Turing tarpits
Oof!

The esoteric programming language Oof! (not to be confused with Oof) was invented by User:Zzo38 in May 2006. It is a bit similar to Black, and to the game Black Box.
The program structure is a 2-D box, the characters are spaces or non-space symbols. The program pointer is at the unique non-space symbol that is moving. When it moves outside the boundary (such that it can't possibly touch anything else) then the program terminates. The program starts by moving the $ (there can be only one in the program) toward the right.
Rules:
* When a moving symbol bumps into a non-space with a different symbol, it stops, and the other symbol starts moving in the same direction.
* When a moving symbol hits a non-space that matches, it pushes the latter (and anything behind it if there are multiple non-spaces in a row) one space in the direction moved, then reverses its own direction.
* When there are non-matching non-spaces next to it like in Black Box, the moving symbol deflects, see below. (Matching symbols don't affect it)
Deflection:
 * *
 .... ...... bounces off
 . *
 .
 deflects
Special symbols:
* The symbols ^ _ < > are special symbols. If they move, they turn into the symbol corresponding to the direction they are moving in.
* The symbols = and | are pullers, = horizontally, and | vertically. (In any other respect they are just like other symbols.) A symbol moving away horizontally from an adjacent =, pulls with it the latter and all non-spaces connected to it. Similarly with |, except vertically. But , A puller of either way, when bumping into another puller (either kind), it immediately reverses and pulls it along with it.
Category:Languages
Category:2006
Category:Cell-based
Category:Usability unknown
Category:Unknown computational class
Category:No IO
Category:Two-dimensional_languages
Category:Unimplemented
Category:Low-level
Category:Self-modifying
Ooh

ooh is a estrotic programming language that will make you go ooh! every time you see a program written in it.
ooh uses 1 instruction only.
 ooh instructions
Instruction	Description
o 	increase ascii value by 1
newline 	print ascii value
(its technically two instructions but its still looks like 1)
== Hello world program ==
 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
 ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
 ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
(it only writes hello but its basically the same)
due to it only being able to print ascii characters, (almost all of them) the langauge is pretty much useless (like most esolangs) however, since you need to write out an o for the value of each character, programs can get BIG.
like this one
== Program that outputs the first Harry Potter book ==
 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
 ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
 oooooooooooooooooooooooo
 (this goes on for 5,847,284,722,283,091,839 characters)
of course an implementation has been made because of how simple it is
== Python implementation ==
 while True:
 code=input(">")
 for c in code.splitlines():
 g=1;
 for i in c:
 if i!="o":g=0
 if g:print(chr(len(c)))
optimzed (by User:Ractangle):
 while True:
 code=input(">");g=0;s=[]
 for c in code:
 if c=="o":g+=1;s.append(c)
 print(chr(len(s)))
== C implementation ==
 coming soon?
that's all to it
Category:Languages
Category:Implemented
Category:Output only
Category:Unusable for programming
Category:Total