OISC

OISC is the One Instruction Set Computer (by analogy with RISC and CISC), a machine providing only one instruction. The abbreviation URISC (Ultimate RISC) has been used in some publications with the same meaning as OISC.
A general focus of OISCs is to be the extremely simple and yet meaningfull (i.e. to allow memory, loops and computation as you know it).
An extremely simple OISC is FlipJump. Its instruction has 2 operands a;b: flip the bit addressed by a, and jump to address b.
A famous OISC language is subleq - subtract and branch if less or equal to zero. This language has three parameters, subleq(a,b,c) - subtracts a from b, stores the result in b, and then transfers control to the address in c if the result was non-positive. Another version is SBN - subtract and branch if negative, which only differ by zero-inclusion. 
Another very simple OISC is BitBitJump. Its instruction has 3 operands as in Subleq, but the meaning is: copy the bit addressed by a to the bit addressed by b and jump to the address c. BitBitJump has a "big brother" ByteByteJump that copies 1 byte at a time instead of 1 bit. Both of these machines belong to a larger class of machines, WordWordJump, that copy b bits at a time but have address operands of size n*b, where n≥2 (e.g. 32-bit addresses and 8-bit data for a 32-bit WordWordJump machine). 
It is this feature that allows FlipJump, BitBitJump, ByteByteJump, and similar machines to perform arithmetic and conditional jumps through the use of self-modifying code.
Some languages use a memory mapped instruction pointer (as in RSSB). Branching is done by writing to IP in these implementations. More advanced memory mapping allows complex functionality such as arithmetic but with the benefit of having a simple copy operation (MOVE, or mov).
Some OISC languages are Turing-complete, making them Turing tarpits, while others are bounded-storage machines, more akin to physical CPUs. Turing-completeness requires the OISC to be defined with sufficient abstraction with respect to both addressing scheme and operand size. For example, Subleq uses absolute addressing and does not specify its operand size, so it is TC. BitBitJump, on the other hand, is defined to use bounded operand size and absolute addressing, so it is only a bounded storage machine. It is not known whether either of these languages with bounded operand size could achieve TC-ness by revising them to use relative addressing. It seems likely, however, because relative addressing is the Turing machine property.
Any OISC language belongs to either one of the two groups: with memory mapping (MOVE, RSSB) or without (Subleq, SBN, FlipJump, BitBitJump, ByteByteJump). Note, that a language from the second group may have an extension with memory mapped special addresses, but those addresses are not required for computations; they are used for IO or any other system calls.
==List of OISCs==
In this table, the OISC's command is given in C-like syntax. a, b, c, etc. are placeholders for arguments to the command, and are treated as literals (thus for example the INC command from x86 assembler would have its semantics written as (*a)++; it's incrementing the value at a specific address, so the address is literal and needs to be dereferenced once in order to produce the value at that address, which is the thing that is incremented). X, Y etc. are placeholders for "magic numbers" that allow multiple variants of an instruction, such as addressing modes. p, q, r, etc. are registers that are not memory-mapped. Many OISCs memory-map instructions (to allow for self-modifying code, often increasing their computational power), and/or the instruction pointer (to provide a method to implement loops). (Some OISCs also memory-map other things, like I/O, but this is not shown in the table below.)
Name 	Command 	Addresses 	Commands memory-mapped 	IP memory-mapped
abcout 	*a += *b; if (*a > 255) { *a %= 256; ip = c; } 	Absolute 	No 	No
Addbig 	*a += *b; if (*a > 0) goto c; 	Absolute 	Yes 	No
AddJump 	++a; goto b; 	Absolute 	No 	No
Addo 	*a += *b; if ((*a % 2) != 0) goto c; 	Absolute 	Yes 	No
BitBitJump 	*b = *a; goto c; 	Absolute 	Yes 	No
Blues machine 	++*a; *b *= *c; *d /= *e; if(*f) goto (g ? h : *h); 	Absolute 	No 	No
ByteByteJump 	*b = *a; goto c; 	Absolute 	Yes 	No
Cryptoleq 	*b = *b/*a; if (*b < 0) goto *c; 	Absolute 	Yes 	No
Decleq 	*b=*a-1; if (*b <= 0) goto c 	Absolute 	Yes 	No
DCI 	if(*a>0){--*a;if(b)*c=b;else *c=*d;} 	Absolute 	Yes 	Yes (address 1)
Divmeq 	if (x % a == 0) {x /= a; goto b;} 	Not used 	No 	No
Divrac 	*e = (a*d)/gcd(a*d, b*c); *(e+1) = (b*c)/gcd(a*d, b*c); 	Absolute(some magic numbers)	No 	Partially
DJN 	(*b)--; if (*b ≠ 0) goto *a; 	Relative 	Yes 	No
FlipJump 	*a=~*a; goto b; 	Absolute 	Yes 	No
Flump 	if (b & *a) *a -= (*a & ~(b-1)) / 2;else *a += (*a & ~(b-1)) + b;if (!*a) goto *c; 	Absolute 	Yes 	No
Hexagon says 	if b == n goto a;if b == d b +=c; if c == e printf(b); 	Absolute 	No 	No
Ichi/Hito 	cells[x % 2] += (int)(x / abs(x)); if (cells[x % 2] == -1) else goto abs(x) / 2;} 	Absolute 	No 	No
I/D machine 	*p += a; p = *p; 	Not used 	No 	No (implicit loop around program)
IDIJ 	(*a)++; (*b)--; if(*c==0) ip=d; 	Absolute 	No 	No
Indivisible 	if(*x % ip) *x *= ip; 	Absolute 	No 	No (implicit loop around program, however IP used in instruction)
INJUQ 	*a+=*b; if (*a = *c) goto d; 	Absolute 	Yes 	No
JCLN 	b: if(a==-1)a=__LINE__; if(__LINE__==a) goto b;//There has to be a "b" tag on every command. 	Absolute 	Yes 	No
Lag 	a: b -= c; if (b == 0) goto d; 	Absolute 	No 	No
MISC 	*a = ((d & X) ? b : *b) - ((d & Y) ? c : *c);goto *(d & ~X & ~Y); 	Relative 	Yes 	No
Multleq 	*a *= *b; *a += *c; if (*a <= *d) goto e; 	Absolute 	Yes 	No
Nutes 	s = signum (*(x--)) + signum (*(x++)); *(x--) = *(x--) - *(x++); *(x++) = -*(x--); if (s < 0) goto *((*x)--); if (s == 0) goto **x; if (s > 0) goto *((*x)++);	Relative 	No 	No
OISC:2 	if a,b >= 0: *b = *b - *a; else special opcodes 	Absolute 	Yes 	Yes
OISC:3 	if a,b,c >= 0: *c = *b - *a; else special opcodes 	Absolute 	Yes 	No
OISCalypse 	if(*p+a<0) ip=0; else *p+=a; p++; 	Not used 	No 	No
RSSB 	*a = *1 = *a - *1; 	Absolute 	Yes 	Yes
SBN (SBN2) 	*a = p = p - *a; if (p < 0) goto *b; 	Absolute 	No 	Yes
SBN (SBN3) 	X = X - Y; if (X < 0) goto *p; (aka subneg) 	Absolute 	No 	Yes
SBN (SBN4) 	Z = X - Y; if (Z < 0) goto *p; (aka subneg4) 	Absolute 	No 	Yes
Smaller 	a += b; if (a = 0) goto 0; 	Absolute 	No 	No
sranbsleq 	e = d - ((a >> b) & !c); if(e <= 0) goto f; 	Absolute 	No 	No
SUBBIG 	*a-=*b; if (*a > 0) goto c; 	Absolute 	Yes 	No
S*bleq 	*a-=*b; if (*a <= 0) goto *c; 	Relative 	Yes 	Yes
Subleq 	*b = *b - *a; if (*b <= 0) goto c; 	Absolute 	Yes 	No
Subskin 	*c = *a - *b;if (*c < 0) goto *(ip + 1); 	Absolute 	Yes 	Yes
SICO 	if (*a <= *b) ip = c;else *a -= *b; 	Absolute 	Yes 	No
Simpler Subskin 	*a -= *b;if (*a < 0) goto *(ip + 1); 	Absolute 	No 	No (implicit loop around program)
Three Star Programmer	(***a)++; 	Absolute 	No 	No (implicit loop around program)
Tip 	ip *= a; 	Absolute 	No (program repeats forever)	No (but halt on IP 0)
TOGA computer 	not *a; if (*a) goto b; 	Absolute 	No 	No
XOṘ Mạchịne 	a ^= b; /*or any command like this*/ printf("%d",a>b); 	Not used 	No 	No
 
Additionally, the non-esoteric transport triggered architecture also has only one instruction, move.
==Papers==
* The Ultimate RISC - 1988 Describes MOVE
* Single Instruction Set Architectures for Image Processing - 2002
* URISC: The Ultimate Reduced Instruction Set Computer - 1988 Describes SBN
==See Also==
* Zero Instruction Set Computer
==External resources==
* The Retrocomputing Museum, with OISC emulator
* MISC
* Self-interpreter for subleq based OISC
* Flipjump assembler, standard-library and interpreter
* Compiler C-like language into Subleq
* C to FlipJump Compiler
* BitBitJump emulator 
Category:Concepts