nyuuzyou/wikis huggingface dataset:
Abcout

:Note that abcout is typically lowercased, even at the start of a sentence.
abcout (add and branch if carry out) is an OISC created by sporeball in 2020.
==Overview==
This OISC was first posed over Discord on February 26, 2020:
sporeball 02/26/2020
trying to conceptualize how to design an OISC
however i feel like the standard subleq a, b, c would be hard to build a circuit for (at least for me)
how computationally powerful would, say, an "add and branch if carry out" instruction be?
Each instruction takes the form A, B, C, and does what the above description would suggest: memory address A will have the value of memory address B added to it, and execution will branch to the instruction beginning at memory address C if the result is greater than 255, or to the next instruction in sequence otherwise. It is assumed that memory addresses A and B both contain an unsigned 8-bit integer.
abcout does not memory-map its instructions, in contrast to other OISCs, and instead keeps instructions and user space in separate blocks of memory.
==Implementations==
Unlike with her previous language, naz, the author did not immediately opt to complete a software implementation of abcout; instead, as of April 2021, she is attempting to implement it in hardware, in the form of a machine christened as the ABCO-1. Because this has not been completed, the language is as of yet unimplemented.
==External resources==
* ABCO-1 on GitHub
Category:Unimplemented
Category:Languages
Category:2020
Category:Unknown_computational_class
Category:OISC
Aboba

An esolang created in 1 day.
Inspired by Brainfuck, but very different from it.
Should be turing complete.
Extensions: .b.
===Instructions===
Command 	Action
+N 	Increment open variable by N
-N 	Decrement open variable by N
%N 	Open N variable
" any text	1-line comment (aboba ignores all not listed here characters, but you still better make comments like this)
?> or ?< 	If open variable is 0, loop back or forward in code until wall (sorry, cannot put that character here) met.
in or ic 	Input (N)umber or (C)harater (as ASCII code) in open variable.
{ and } 	Brainfuck-like loop: enters if not zero, exits if zero
[N C] 	Execute (C)ommands only if open variable == N
( and ) 	Outputs from open variable as character (from ASCII code) if (, or outputs as number if ).
~ 	Ends program.
sC 	Does stack operation. C may be this: 
p - pushes open variable 
g - pops open variable 
d - duplicates top value 
w - swaps top 2 values 
+, -, * or / - perform math operations (top value OPERATION other value)
 
All other chars are ignored completely.
===Examples===
"Hello World!"
 %1 +72 ( +29 ( +7 ( ( +3 ( -79 ( +55 ( +24 ( +3 ( -6 ( -8 ( -67 (
Calculator (1 and 2 is numbers, 3 is operator)
 %1 in sp %2 in sp sw %3 ic
 [43 s+ sg ) ~]
 [45 s- sg ) ~]
 [42 s* sg ) ~]
 [47 s/ sg ) ~]
 %0 +73 ( +37 ( +8 ( -21 ( +11 ( -3 ( -5 ( -67 (
 ~
Fibonacci sequence (up to 17711)
 %1 )
 %4 +10 (
 %2 +1 ) 
 %4 (
 {
 	%1 sp 
 	%2 sp
 	s+ %3 sg )
 	%4 (
 	%2 sp
 	%1 sg
 	%3 sp
 	%2 sg
 	[17711 ~]
 }
===Interpreter===
Currently only Python interpreter available for my language.
To use it, do:
 $ python3 aboba.py <filename>
==External links==
* Python interpreter
Category:Languages
Category:Turing complete
Category:Implemented
Abraham Karplus

Abraham Karplus is an esoteric programming language creator who participates in this wiki as User:Maharba. He has created the esolangs
* SyL
* DigFill
* Alight
* Pirandello
* Symesol
* Deadfish i (an object-oriented version of Deadfish)
He has also implemented Arborealis in Python, available on Pastebin.
Category:People
Abstract machine

An abstract machine is a hypothetical device in computer science that performs actions, possibly based on input provided. They are typically not bounded by the confines of reality. An example of an abstract machine is a Turing machine.
== Types of abstract machine ==
=== Turing machine ===
A traditional Turing machine comes in two parts: A reader head and a tape. On the tape are symbols that can be read and written to by the reader head. The reader head has a "state" and a set of rules. It reads the cell under it and, dependent on its current state and the value of the cell and what those two values correspond to in the rule table, it:
* Sets the cell under it to a certain symbol
* Goes to a certain state
* Moves either left or right along the tape
Category:Concepts
Absurd Brainfuck

Absurd Brainfuck is a Brainfuck-derivative by User:Tailcalled. It is called 'absurd' because the side effects flow in the opposite direction of the data. In other words, when you change a cell, you change what it *was*, not what it is. This can lead to undecidable or paradoxical scenarios, of course, especially when using the , command.
== Commands ==
Absurd Brainfuck has the commands of Brainfuck, but with a "slightly" different effect.
 + Changes the current cell to be one higher in the past
 - Changes the current cell to be one lower in the past
 > Goes to the next cell in the past
 < Goes to the previous cell in the past
 . Outputs the current value of the current cell.
 , Reads a value and puts it in the current cell in the past.
 [p] Executes p until the value of the current cell is 0.
== Memory ==
Absurd Brainfuck has an infinite tape in *both* directions.
== Computational Class ==
Aside from one command, all temporal effects are reversible, so one can calculate the effect of reversing them, and those commands are trivial substitutions for Brainfuck ones. Absurd Brainfuck is a Turing machine with non-deterministic effects when it comes to the input. However, many languages are non-deterministic when it comes to input; the difference is that in Absurd Brainfuck inputs can easily cause undefined behaviour or contradictions, and only specific deterministic inputs cause the program to continue unimpeded.
Category:2012
Category:Brainfuck derivatives
Category:Languages
Category:Turing complete
Aceto

Aceto is an esoteric programming language made by L3viathan, designed according to the wishes of @sarnthil. The name has no meaning other than being a reference to OIL. It is a stack-based language where the pointer moves on a simulated Hilbert curve.
== Language description ==
An Aceto program is a square text file. If the file does not look like a square (with side length 2^n for some n), it gets filled with spaces to the right and top (!) until it is. The pointer then starts at position 0,0 (which is the bottom left!) and from then on follows the path of a Hilbert curve to read instructions.
Aceto has an infinite tape in each of which is a stack. The program starts with one of these stacks as the active stack.
== Implementations ==
An official implementation as well as a more in-depth description of the language can be found here.
== Examples ==
Hello, World!
pdcpcpdc
p3+4-3+p
dc*8*73d
+dcpd3+c
4-3dpcdp
pc*+8--3
9*48pcIc
8dcp48*p
Cat Program
rp
Category:2017Category:ImplementedCategory:Turing completeCategory:Low-levelCategory:Two-dimensional languagesCategory:Cell-basedCategory:Stack-basedCategory:Languages
Ackermann function

The Ackermann function is probably the most well-known example of a function that is computable but which grows so extremely fast that it is not primitive recursive. Thus being able to calculate it is a test of the computational class of a language.
It is a function of two natural numbers, returning a natural number. Its definition is by recursion in two variables:
 unsigned int A(unsigned int m,unsigned int n) {
 if (m==0) { return n+1; }
 else if (n==0) { return A(m-1,1); }
 else { return A(m-1,A(m,n-1)); }
 }
==External resources==
* Wikipedia:Ackermann function
Category:Program forms
Acme::Bleach

Acme::Bleach is a language that executes arbitrary perl code disguised in an encoding consisting of only whitespace characters. Each character of the perl source code is encoded in eight bits, the bits represented in the Acme::Bleach source code by space and tab respectiveliy for 0 and 1, and a newline after the bits of each character. The Acme::Bleach perl module can interprets the language or translate perl code to it. Acme::Bleach was created by Damian Conway in 2001.
== Links ==
* Documentation of the implementation on Metacpan
== See also ==
* Whitespace, a lower level language where source code contains only the same three characters.
Category:Languages
Category:Implemented
Category:2001
Category:Turing complete
Category:High-level
Action symbol

Action symbol is a simple Matrioshka language based on the danish word for . it was created by User:Yayimhere.
== how it works ==
the program has two types of syntax:
 x[y](z) will create an operator x with input y, that will return the result of expression z. z must hold at least one "
 x!y apply x operator to y
 "x evaluate x. normally an expression is not evaluated unless its NEEDED. " will not need to be itself evaluated
 »x« when x is evaluated do it separately from the rest of the expression(basically brackets in normal expressions)
programs are also when evaluated lazily and left to right.
== relation to Lambda calculus ==
in a version of lambda calculus where first of all variables can be defined and also a expression is only evaluated when it would be passed to a function:
 {x[y](z)} -> x = \y.{z}
 {"x} -> (\y.y) {x}
 {x!y} -> {x} {y}
 {»x«} -> ({x})
where converts to this lambda calculus
== examples ==
 w[x]("»x!x«)
 o[x]("»w!w«)
o is now the omega combinator
 j[y]("x)
 k[x]("j)
k is now k from SKI combinator calculus
Category:Languages Category:2024
AddJump

AddJump(Add 1 and Jump to command) is an OISC by User:ChuckEsoteric08 and inprised by FlipJump.
==Command==
 a;b;
Increment variable a by 1 and Go to command b(1-indexed). You can go to command which specified by variable by putting it between two "%"s:
 a;%a%;
It will increment variable "a" and go to command specified by variable "a"
==SaddJump==
SaddJump is Self-Modifying AddJump where command
 a;b;
is increment memory address a and go to memory address b.
Relative addresses can be used: [a] is value in memory address a, [[[a]]];b; implements Three Star Programmer
SADDJMP-n is SADDJUMP where memory address can be n-bits long(wrapping):
*SADDJMP-8 uses 8-bit addresses
*SADDJMP-16 uses 16-bit addresses
*SADDJMP-32 uses 32-bit addresses
==See Also==
*FlipJump
*Addleq
*P1eq
==External resources==
*Compiler from AddJump to Batch
Category:Languages Category:OISC Category:Implemented Category:Unknown computational class
Addbig

Addbig is a OISC created by User:Joaozin003 which the only instruction is "Add the values of A and B, store the result in A and branch to C if the result is bigger than zero."
This instruction can be written in C with the code:
 *a += *b; if (*a > 0) goto c;
It is also the literal opposite of Subleq.
== Programming in Addbig ==
=== The full Addbig instruction ===
In C:
 if (b < 0) *a += scanf();
 else *a += *b;
 if (a < 0) {
 printf("%c", (char)*a);
 *a = 0;
 }
 if (*a > 0) {
 if (c < 0) return;
 else goto c;
 }
=== Memory Mapping ===
Since Addbig has no I/O, it is memory-mapped to addresses less than 0. Adding from -1 means input, and adding to -1 means output (the result does not go to address -1, it goes to the console, effectively discarding the result (for discarding the result by not using output, discard it into an unused address)).
And jumping to -1 effectively means ending the program, as that address is useless as an instruction (the first actual instruction is at address 0, the start of the program).
=== Storage of data ===
Data can be stored in lots of ways, but I'm just showing one:
==== The Stack ====
A stack is a way of storing data which follows the "first in, last out" pattern.
===== Stack Push =====
Stack push puts a value on top of the stack, and increases the stack pointer. I'm going to label the stack pointer with "sp" to help traverse code.
 sp v 3 # v is the value to push
 0 1 ... # increment stack pointer
===== Stack Pop =====
Stack pop takes a value out of the stack, stores it somewhere and decreases the stack pointer.
 3 sp 6
 0 0 -1
 # zeroing out old stack top code goes here
 1 5 ...
== Examples ==
Here are some examples to show off the OISC:
=== Hello Program ===
 -1 15 3
 -1 16 6
 -1 17 9
 -1 18 12
 -1 19 -1
 72 101 108
 108 111
The junk below the first 5 instructions is actually data to output (more precisely, the string "Hello" in ASCII), which never gets jumped to.
=== Negation ===
 4 -1 6
 0 0 -1
 4 5 12
 3 5 6
 -1 3 15
 0 0 -1
The program above takes a number, negates it, and outputs the negated number. The program uses looping to emulate subtraction from 0, which effectively means negation.
=== Cat Program Until <=0 ===
 -1 -1 0
 2 3 -1
Indeed, this is one of the simplest programs ever.
===Truth-Machine===
A truth-machine is implemented in the following:
 0 -1 3
 0 12 9
 -1 13 -1
 -1 14 9
 -48 48 49
== See also ==
* Subleq
==Interpreter==
* Common Lisp implementation of the Addbig programming language.
Category:Languages
Category:OISC
Category:Usability unknown
Category:Unimplemented
Addleq

Addleq is a Turing-complete OISC language invented by Oleg (thank r.e.s.), very similar to Subleq, with the exception that it uses addition operation instead of subtraction. However it is much harder to program in Addleq than in Subleq.
Because of similarity to Subleq, the exactly same assembly notation can be used.
==Elementary operations==
The following variable definitions can be useful
 . Z:0 dec:-1 inc:1 t1:0 t2:0
Z is zero and should not be changed, dec and inc are useful for decrementing and incrementing, t's are temporary variables.
If A has value and B is 0, then copying A to B as as simple as
 A B
If B is not zero, it has to be known if it is greater or less than zero. It is possible to clear B, for example, in the following way. Suppose that B is not less than 0, then
 inc B
 dec B ?+3
 Z Z ?-6
does the trick. Obviously there is a much faster solution (not presented here) which doubles negative unit and recursively builds a negative counterpart. 
As in Subleq assembly ? signifies the address of the next memory cell. So the example above is the same as
 inc B
 repeat: dec B do_smth_else
 Z Z repeat
 do_smth_else:
 ...
If B>0 than
 . Z:0 dec:-1 B:0 
 dec B ?+3
 Z Z ?-6
which compiles into
 0 -1 0
 1 2 9
 0 0 3
==Input/Output==
Input and output operations can be defined exactly as in Subleq with a specail address (-1). This program echos input:
 # Echo
 start:
 -1 x (-1)
 x (-1)
 
 # clear x
 dec x start
 Z Z ?-6
 
 . Z:0 dec:-1 x:0
==Hello, World!==
"Hello world" program is a bit more complex. For dereferencing operation the same technique as in Subleq can be used.
 # Hello world!
 
 # output *p; 
 dec a ?+3; Z Z ?-6
 p a
 a:1 (-1)
 
 # p++
 inc p
 
 # clear temps
 dec t1 ?+3; Z Z ?-6
 dec t2 ?+3; Z Z ?-6
 
 # t2=(-p+1)
 p t1
 dec t1 ?+3
 dec t2 ?-6
 
 # check if p<E
 dec t2
 dec t2 # now t2==-p-1
 E t2 (-1)
 Z Z 0
 
 . p:H Z:0 dec:-1 inc:1 t1:0 t2:0
 . H: "Hello, World!\n" E:E
In the above program the pointer is being checked for reaching the end (p==E). It is possible also to check the dereferenced value. In this case the program becomes a bit simpler:
 # Hello world!
 
 # prepare *p in a and b
 dec a ?+3; Z Z ?-6
 dec b ?+3; Z Z ?-6
 p a; p b
 
 # check that b>0
 dec t ?+3; Z Z ?-6
 b:1 t (-1) 
 
 # output a
 a:1 (-1)
 
 # p++
 inc p
 
 Z Z 0
 
 . p:H Z:0 dec:-1 inc:1 t:0
 . H:"Hello, World!\n\0"
==How to run Addleq programs==
Use sqasm.cpp to compile assembly program into the Addleq code. Then sqrun.cpp with the option (-a) to run the compiled code.
==See also==
* Subleq
* P1eq
* DJN OISC
==External resources==
* Addleq on Oleg Mazonka's site.
Category:Languages
Category:Implemented
Category:Turing complete
Category:2009
Category:OISC
Addo

Addo(Add and jump if odd) is an OISC by User:ChuckEsoteric08
==Description==
 a b c
Add memory addresses a and b storing result in a and if result was odd jump to memory address c.
Every location that does not exist is always 0.
==Examples==
===Simple Example===
This program, deprived of veridical utility, demonstrates the basic principles by jumping twice: once from the position zero (0) to the last line, and finally to its perdition via -1:
 3 4 6
 1 2 3
 3 4 -1
==Interpreter==
* Common Lisp implementation of the Addo programming language.
Category:Languages Category:OISC Category:Self-modifying Category:2022 Category:Implemented
Addpocalypse

Addpocalypse is a simplification of Brainpocalypse II by User:Pro465. The author hopes, but does not, at the time of writing, know if it's TC.
== Operation ==
Instruction	Meaning
n+ 	increments value in register #n
n? 	jumps to start of program if value in register #n != value in register #0
(Whitespace is ignored.)
Since 0? is a nop, its syntax can be further simplified to only lists of integers, where a negative value -n denotes n? and nonnegative value n denotes n+
== Sample program ==
input: x in register #1 (x != 0)
output: 3x in register #2
0+
2+2+2+
1?
Adj

Adj (a is ADd a to b, then Jump to c) aka a=a+b; goto c
command = ADJ a b c
label = x:
add only = ADJ a b X
jump only = ADJ X X c
output = ADJ 0 b c or ADJ 0 b X
input = ADJ 1 b c or ADJ 1 b X
= Examples =
== Add 1 and 1 ==
 ADJ a 1 X
 ADJ b 1 X
 ADJ a b X
 ADJ 0 a X
== Add in1 and in2 ==
 ADJ 1 a X
 ADJ 1 b X
 ADJ a b X
 ADJ 0 a X
== Jump to line ==
 ADJ 1 a X
 ADJ X X a
Category:Languages
Advanced Brainfuck

The Advanced Brainfuck is an extension of the brainfuck programming language. It adds the ability to switch to "file mode".
to open a file (/dev/stdin for instance), you can use the switch operator '~'. It will open the file with the address corresponding to the string starting at the current memory pointer position (which should be ended by \0).
Once open, you are in "file mode" the '.' operation copy from the file to the memory, and the ',' operation copy from the memory to the file. To switch back to "memory mode", reuse the '~' operator. In this case the operators are reversed, '.' copy from the memory to the file and ',' copy from the file to the memory.
Each time you read/write a file in memory mode, the file pointer is automatically shifted by +1.
Each time you read/write the memory in file mode, the memory pointer is automatically shifted by +1.
If you are in file mode, the reading overwrite the memory where was the pointer, so the file address. If you switch back to memory, you can shift the memory pointer and still get data from the file with the operator ','. But to shift the file pointer by a custom value, you need to reopen it.
TapTempo.abf is a commented example that opens stdout, stdin and /proc/uptime to get an implementation of TapTempo:
Category:Brainfuck derivatives
Category:Languages
Category:2018
Aeolbonn

Aeolbonn (An esoteric output language based on natural numbers) is a Turing-complete esoteric language designed by Keymaker.
==Overview==
Aeolbonn has infinite memory of boolean values, asterisk that can have any value from zero to upwards, and flip that is a boolean flag that'll receive the new value of a memory cell every time a memory operation has been performed. Execution starts at line 0 and will continue until the instruction pointer is outside the program area. Data that doesn't form valid instructions will result to undefined behaviour if encountered by the program pointer. Asterisk is initially zero and all the memory and flip are false.
==Instructions==
Aeolbonn has six instructions, one instruction per line. Some instructions are single ASCII characters while others may consist of thousands of digits (in theory).
The instructions are the following:
* Odd values perform a memory operation. The bit at memory cell defined by this odd value will be flipped. Flip will get the memory cell's new value.
* Even values perform a conditional jump. Jump is performed if flip is true, otherwise the execution continues on the next line.
* '>' and '<' increase and decrease asterisk.
* '?' makes flip randomly true or false.
* ':' outputs the characters on line after it (excluding new-line). If there's nothing but ':' on the line, a new-line will be printed.
* '*' works just as any odd or even value does. It technically isn't an instruction.
==Examples==
===Infinite loop===
 0
 1
 2
Even value on line 0 (0), tries to perform a jump but doesn't succeed as flip is initially false, so the execution continues to the second line. On second line the bit in memory cell defined by this odd value (1) is flipped, and flip will receive the memory cell's new value, 'true'. On third line a jump is performed to line number 2, defined by the even number 2. Then, again on line 2, a jump will be performed to line 2.. Then it will be performed again, again, and again.. Ad infinitum.
===Hello, world!===
 :Hello, world!
 :
This program prints out "Hello, world!" along with a new-line.
===Truth-machine===
 0
 1
 8
 1
 :1
 :
 4
 1
 :0
This program takes the first line as an input.
==External resources==
* Aeolbonn page (features specs, programs, and an interpreter)
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Cell-based
Category:Output only
Category:Implemented
Category:2006
Aepoch

Aepoch is a Bully automaton made by Areallycoolusername. It has some properties added to resemble the properties of a fractal.
== Specifics ==
Aepoch starts out with an infinite grid of integer cells of undefined value.
# A specified cell, now called the initial cell, is set to 0.
# The 4 cells adjacent to the starting cell are set to the initial cell.
# The function f(x) = x^2 + 4x is applied to each cell.
#* A cell set to 0 is unchanged, as f(0) is still 0.
# The cell 2 cells to the right of the initial cell is set to 0.
#* It will undergo the same process that the initial cell underwent.
# A cell in a point exactly 5 blocks away in a random side of the starting 5 cells will be set to the starting cells state incremented by 1.
#* It will also undergo the same process that the initial cell underwent.
All state changes will happen in 1 clock cycle and will continue to do so until it is stopped somehow.
Category: Unimplemented
Category: Self-modifying
Category: Two-dimensional languages
Category:Languages
Aether

== What is "Aether"? ==
Aether is a programming language made to replace the Minecraft's commands because: They are horrible.
Features of the Aether programming language:
:* Easy to use
:* Easy to learn
:* Lua like
:* Object oriented
:* Cool, I think.
== Documentation ==
I will teach you how tu use this language by showing examples and tell you what every line does.
=== The set command ===
The set command is the most important thing, with this command you will do a lot of things like:
:*Creating variables and changing their values
:*Add/delete/replace blocks
:*Change hunger of players
:*Change health of players
== Examples ==
Now I will show you examples of code.
 // Kill a random player
 set health players.random() 0
 // Refill hunger of every player every 0.5 of a second
 while true do
 read array players.users in player do
 set hunger player 20
 end
 delay seconds 0.5
 end
Category:Object-oriented paradigm
Category:2020
Category:Languages