nyuuzyou/wikis huggingface dataset:
2 trits, 3 trytes

2 trits, 3 trytes is an assembly language invented by User:TheBigH that existed for months but he just didn't make an article on it. It is inspired by 2 Bits, 1 Byte.
==Commands==
Command (Trinary)	Command (Disassembled)	What it does
00 	NOP 	Do nothing (a NOP)
01 	ACT 	ACTion. Given value in memory, completely mix it up according to the following:
00 -> 12 -> 10 -> 20 -> 01 -> 22 -> 21 -> 02 -> 11 -> 00
02 	CJM 	Conditional JuMp. Given two addresses, if the value in the first address is nonzero, jump to the second address.
10 	JMP 	Given value in memory, JuMP to that instruction.
11 	INC 	Given value in memory, INCrease given value (wraps)
12 	DEC 	Given value in memory, DECrease given value (wraps)
20 	TCO 	Given three addresses, Tritwise COnfusion** the first two addresses together and store the result in the third.
21 	OUT 	Given a 2 trit number, OUTput the value of that tryte as a char*. If the number is more than 4, 5 gets subtracted from it.
22 	TEM 	TErMinates the program.
 *This uses a 4-trit version of ASCII. Here's a chart:
 012345678
 
 0 ○░▒π∞↊↋×÷
 1 ¬µ█/'"\?~
 2 `!@#$%^&*
 3 012345678
 4 9.,:;=-_+
 5 ()[]{}<>|
 6 ▓ABCDEFGH
 7 IJKLMNOPQ
 8 RSTUVWXYZ
 
 **Tritwise confusion uses this table (side is input 1 and top is input 2):
 012
 
 0 212
 1 022
 2 011
The instruction pointer can wrap around, thus allowing more "complicated" programs.
Since the memory is 2 trytes, you can represent the entire program with just 5 characters. The last 2 trits of the last character aren't used.
For example:
 !!!!!
becomes:
 02010201020102010201
which, when disassembled, becomes:
 CJM 0x1 0x2
 ACT 0x2
 ACT 0x2
 ACT 0x2
==Programs==
=== Output any 2 characters ===
 CD○??
where the ??? is replaced with the 2 characters.
When disassembled, this becomes:
 OUT 0x3
 OUT 0x4
 NOP
 NOP
 ???
=== Infinite loop ===
 ○○○○○
==Interpreters==
https://snap.berkeley.edu/project?username=lionheart921&projectname=2%20trits%2c%203%20trytes by User:TheBigH
==See also==
* 2 Bits, 1 Byte
* 3 Bits, 3 Bytes
* 4 bits, 8 bytes
* 4 bits, unlimited bytes
Category:Joke languages
Category:Low-level
Category:Unusable for programming
Category:Implemented
Category:Self-modifying
Category:Output only
Category:2024
Category:Languages
Category:Finite state automata
2b

2b is an optimization of 2D BF with 4-7 commands depending on how you count.
== Commands ==
 > go forward
 @ turn right
 = bit flip
 [] brackets
 OPTIONAL COMMANDS:
 . output
 , input
== Corresponding with 2DFuck ==
 v^<> - combinations of > and @
 lrx - not needed for turing-complete
 ! - =
 . - .
 , - ,
 [] - []
 ? - not needed for turing-complete
2d

2d is a programming language that is 2d, but it uses jumping and matching
== Commands ==
 [ ... ], anydir, if the code pointer is 1, jump, else turn around
 ( ... [a symbol that is ] or ) or }], anydir, if the symbol is ), jump,
 elif the symbol is ], then set the ( to the symbol after that,
 elif the symbol is }, turn around and flip the code pointer
 ., end the program with the code pointer value
 ,, input the code pointer value, 1 or 0
 >v<^, change direction, but if it is opposite direction, does not work
 ~num~, numbers that match happen
== Program ==
 (~1~ []) (. ]) (~2~ )~1~ (
 ( )[]
 ( )~2~[]
Category:LanguagesCategory: Two-dimensional languages
2dFish

2dFish is a 2D esoteric programming language made by User:WhoeverKnew123 for fun.
==Syntax==
The syntax is the same as deadfish most of the time. 2dFish also has befunge-like arrows!
The arrows are up: ^ down: v left: \ and right: /
 /iisv
 /isv
 @oii\
The program above this text outputs 27 to the console. (@ is the symbol to terminate program.)
==Computational class==
Not turing-complete. No flow control or anything. It's just deadfish in 2d.
==Instructions==
Instruction	Description
i 	Increment accumulator
d 	Decrement accumulator
s 	Square accumulator
o 	Integer Output accumulator
a 	ASCII Output accumulator
/ 	Set pc direction to right
\ 	Set pc direction to left
v 	Set pc direction to down
^ 	Set pc direction to up
$ 	Input string and store into string variable
% 	Input integer
(string) 	Store string to string variable
* 	Output string variable's value and remove value from string variable
@ 	Terminate program
==Examples==
===Hello World!===
 /(Hello World!)v
 @aaaaaaaaaaaa \
or
 /(Hello World!)*@
===Cat program===
 /$*@
==Implementations==
A C++ interpreter by User:Bangyen.
Category:Languages Category:Two-dimensional languages Category:Implemented
2dLang

2dLang (too-dee-lang) is a programming language that uses cellular automata to make stuff
== Instructions ==
=== Cells ===
write CELLS in a single line for the lines below CELLS are the cells and above are the rules
 #nothing
 CELLS
 THIS
 DOES
 NOTH
 ING_
=== Rule ===
write a diagram to make a rule
 # -> _
 _ #
 CELLS
 #___
 _#__
 __#_
 ___#
the result is:
 ____
 ____
 ____
 ####
== Examples ==
=== Hello world ===
 CELLS
 HELLO_WORLD
=== Booleans ===
 0& -> _N
 1& -> _Y
 N0 -> _0
 N1 -> _0
 Y0 -> _1
 Y1 -> _1
 !1 -> _0
 !0 -> _1
 CELLS
 0&0
 0&1
 1&0
 1&1
 !0
 !1
Category:Languages Category:Two-dimensional languages
2dProperties

2dProperties is a 2d programming language that uses Properties of objects to do stuff
= Instructions =
 o - makes an object that moves right, use ><^v to change directions
 ><^v - changes directions for objects
 * - waits until another object goes on it and makes the other object go the same direction that the object was moving
 & - sets the value property of the object that was on the top of the stack of objects to the value property of the object on the bottom of that
 @ - sets the value property to the next character
 % - swap the top and bottom objects of the stack of objects
Category:Languages
2dthings

2dthings is a programming language that uses things that interact with each other
== Commands ==
 "o" a ball that just rolls right unless interacts with mirror
 "v>^<" a mirror that can change the direction of a ball
 "?" a checker that checks if a ball is there and if there is then turn the checker to a unchecker
 "!" a unchecker that checks if a ball is there and if there is then turn the unchecker to a checker
 "Y" a branch and if a ball goes on it, if the ball has a checker, go through and take away vvv
 the checker, else if it has a unchecker, turn around and take away the unchecker, else destroy the ball
 "O" a hole that when a ball goes into it, it will go to the next hole in the same direction note: example is oOskippedOisnotskipped
 "&" a sucker that when a ball goes into it, the ball will be destroyed
 "@" a picker upper that when a ball goes on it, it makes the ball pick up the (un)checker to the right of it
 "*" returns the thing the ball is holding
Category:Languages
2iota

2iota is an esoteric programming language devised by Chris Pressey in 2004. The successor to beta-Juliet and Portia, it is fairly minimal, aiming to be an event-oriented Turing tarpit.
==Etymology==
The name 2iota, like the names of beta-Juliet and Portia, comes from a "alphabetical" pun on the name of a make of car. It is pronounced like "too-eye-OH-tah" /tu:.aı.oʊ.ta/.
There is no relationship between 2iota and Iota, nor between 2iota and Biota.
==Language description==
A 2iota program consists of a set of events. Each event is named by a string of one or more symbols and optionally a pattern. Each event also names what events it causes in a chain reaction.
A program can also define one or more finite alphabets. If the symbols in the name of an event are members of an alphabet, they can be 'incremented' and 'decremented'.
==Example programs==
The following program implements a 1Hz "clock":
 event Oscillator goes High, causes Oscillator goes Low after 0.5 s;
 event Oscillator goes Low, causes Oscillator goes High after 0.5 s.
==Computational class==
Unlike beta-Juliet (which lacked patterns) and Portia (which allowed only a finite expansion of patterns), 2iota allows a technique something like Gödel numbering to construct names of events; in this manner concepts such as an (unboundedly) "next" event can be named, as illustrated in the following example.
 alphabet DominoNumber,
 One, Two, Three, Four, Five, Six, Seven;
 
 event Begin,
 causes Domino One Falls;
 event Domino (N = DominoNumber+) Falls,
 causes Domino (succ N) Falls.
Since this implements a simple (runaway!) unbounded counter, the author suspects 2iota to be Turing-complete through reduction from a Minsky machine. This has not yet been formally proven, however.
==External resources==
* 
Category: Implemented Category: Languages Category: Turing tarpits Category: Turing complete Category:2004
2th

2th (pronounced "tooth") is a brainfuck variant.
It is meant to add some apparent "improvements" to brainfuck that don't actually help very much.
2th is like brainfuck, except it has an added mode and an added register called "R" which is initially set to 0,
there are 2 additional commands: % and ^ which change the mode, which changes what the other commands do (see the table below).
There is cell mode (the default) and register mode (new).
In addition, the run length encoding of all instruction character types is allowed in 2th.
The file extension for 2th files is, ostensibly, .2th.
==Benefits==
Compared to the original, there are a few advantages that 2th has:
# The run length encoding reduces program length and increases readability.
# The R register then is useful for temporary values too, which also reduces program length.
==Instructions==
 Instructions table
Instruction character	Effect in cell mode 	Effect in register mode
% 	none 	switch to cell mode and replace the value of R with the value of the current cell
^ 	switch to register mode and replace the value of R with the value of the current cell	none
> 	move right in memory 	move right in memory and load the value of the current cell into R
< 	move left in memory 	move left in memory and load the value of the current cell into R
+ 	increment the current cell 	increment R
- 	decrement the current cell 	decrement R
? 	read input into the current cell 	read input into R
. 	write out the value the current cell 	write out the value of R
[ 	loop begin based on the value of the current cell 	loop begin based on the value of R
] 	loop end based on the value of the current cell 	loop end based on the value of R
==Run length encoding==
To elaborate on the run-length encoding, any decimal integer > 0 is allowed in front of a command character.
The decimal number must be series of consecutive decimal digits, so 99 4+ is equivalent to ++++ and not 994 pluses.
At least one of the digits must not be a '0', otherwise, the whole number counts as a '1'.
That is, 0+ and 0000+ are both equivalent to 1+, which is equivalent to +, and 03+ is equivalent to +++.
There must be no other characters (not even whitespace) between the number and the command character for the number to have the effect of multiplying said command character.
That is, 4 + is equivalent to + and not ++++.
==Examples==
"Hello world.2th" (this does not switch modes):
 >8+[<9+>-]<.>4+[<7+>-]<+.7+..3+.>>6+[<7+>-]<++.12-.>6+[<9+>-]<+.<.3+.6-.8-.3>4+<8+>-]<+.
==Implemenations==
* 2th/AuthorImplementation.c
Category:Languages
Category:2023
Category:Brainfuck derivatives
Category:Turing complete
Category:Implemented
Category:Cell-based
Category:Low-level
2xNeg

2xNeg is an esoteric programming language based on two types of negation. 
== Syntax ==
 COMMAND : (NOPARCOMMAND|ONEPARCOMMAND|TWOPARCOMMAND)
 NOPARCOMMAND : ("v"|"{"|"?")
 ONEPARCOMMAND : ("~"|"-"|"}"|"!") PARAMETER
 TWOPACOMMAND : ">" PARAMETER PARAMETER
 PARAMETER : (COMMAND +) "^"
== Commands ==
 v
Pushes 0 on the stack.
 ^
Pops anything from the stack as parameter for the preceding operator.
 ~
Bit-negates the following parameter.
 -
Negates the following parameter.
 > 
Pushes 1 on the stack if parameter 1 is bigger than parameter 2, else pushes 0.
 {
Marker for a loop.
 }
Jumps back to the first { found in a reverse search if parameter 1 > 0
 !
Outputs the first parameter as ASCII char.
 ?
Inputs a char, which will be converted to an ASCII number and pushes it on stack.
Category:Stack-based
Category:2017
Category:Languages
3ME

3ME is an attempt to emulate Sorry, Marvin! in one instruction by Unname4798.
== Implementation ==
var reg = [0,0,0,0];
var progp = 0;
var regp = 0;
var MMME = function (prog) {
 while (true) {
 if (prog[progp] >= 0) {
 regp = regp + 1 % reg.length;
 reg[regp] += prog[progp];
 progp++;
 } else {
 if (reg[regp] > 0) {
 reg[regp]--;
 progp++;
 } else {
 progp = progp + abs(prog[progp]) % prog.length;
 }
 }
 return reg;
 }
}
Category:2024
Category:Implemented
Category:Languages
Category:OISC
Category:Turing complete
3 (AndrewBayly)

3 is an esoteric programming language which is a subset of JavaScript. In 3, every sequence of 3 consecutive characters must contain at least one 3.
==Sample Programs==
===Hello, world!===
 _3='3f3i3n3d3c3o3s3t3r3u3e3l3.3g3(3"3H3 3W3r3)3!3'
 3
 f3=_3[3/3]
 3
 i3=_3[3]
 3
 n3=_3[3+3/3+3/3]
 3
 d3=_3[3+3+3/3]
 3
 c3=_3[3*3]
 3
 o3=_3[3*3+3/3+3/3]
 3
 s3=_3[3*3+3+3/3]
 3
 t3=_3[3*3+3+3]
 3
 r3=_3[3*3+3*3-3/3]
 3
 u3=_3[3*3+3*3+3/3]
 3
 e3=_3[3*3+3*3+3]
 3
 l3=_3[3*3*3-3-3/3]
 3
 D3=_3[3*3*3-3+3/3]
 3
 g3=_3[3*3*3]
 3
 O3=_3[3*3*3+3-3/3]
 3
 Q3=_3[3*3*3+3+3/3]
 3
 H3=_3[3*3*3+3+3]
 3
 S3=_3[3*3*3+3*3-3/3]
 3
 W3=_3[3*3*3+3*3+3/3]
 3
 r3=_3[3*3*3+3*3+3]
 3
 C3=_3[3*3*3+3*3+3+3-3/3]
 3
 E3=_3[3*3*3+3*3+3+3+3/3]
 3
 F33=f3+i3+n3+d3
 C33=c3+o3+n3+s3+t3+r3+u3+c3+t3+o3+r3
 a33=c3+o3+n3+s3+o3+l3+e3+D3+l3+o3+g3+O3+Q3+H3+e3+l3+l3+o3+S3+W3+o3+r3+l3+d3+E3+Q3+C3
 b33=[3]
 3
 c33=b33[F33]
 3
 d33=c33[C33]
 3
 e33=d33(a33)
 3
 f33=e33(3)
 3
== Computational class ==
Arbitrary integers can be built from 3+-/ by adding and subtracting 3/3. You can then get most characters by doing this:
 q3="3\"3"[3/3]
 3
The remaining characters can be done like so:
 // Assuming A3 contains "A", b3 contains "b", etc.
 a33=A3[c3+o3+n3+s3+t3+r3+u3+c3+t3+o3+r3][3,f3+r3+o3+m3+C3+o3+d3+e3+P3+o3+i3+n3+t3](3/3+3/3+3/3+[...])
 3
This allows for arbitrary JS to be run, which proves that 3 is Turing-complete:
 F33="3"[3,a3+t3][3,c3+o3+n3+s3+t3+r3+u3+c3+t3+o3+r3]
 3
 F33([...])(3)
Category:Languages Category:Esoteric subset Category:Turing complete
3 (islptng)

3 is a stack-based esolang that is just 1 with more commands and less constants.
==Syntax==
Totally 28 commands, they are 0134,.;:!=@~-_|+*/%^\?$![]<>
3 Pushes 3 to stack.
= Duplicates top value.
0 Rotates top 3 values(Take the 3rd to the 1st)
# Swaps top 2 value.
, Get a character from input. Pushes its ASCII value.
; Get a number from input and push it.
@ Halt.
Pop a value:
4 Waste it.
~ Sine it(radians).
- Negate it.
_ Floor it.
| Push absolute value of it.
1 Push its sign (1, 0 or -1)
. Prints it in character.
: Prints it in number.
Pop 2 values:
+ Addition.
* Multiplication.
/ Division. Divisor popped first.
% Modulo. Divisor popped first.
^ Power. Exponent popped first.
\ Root. Exponent popped first.
Controllers
?a$b! pop, if > 0, do a, else do b.
[a] while top value > 0 do a.
2nd stack
< Pop from 1st and push into 2nd.
> Pop from 2nd and push into 1st.
If you pops from an empty stack, it returns 3 instead of throwing a error.
==Examples==
===Hello World===
 33/-3+3^33**.33^3*33^+33+33/+-+=.33+33/++===..3+=.33*3+33/-+333/+*=.33+3/33+33/-+^.33+3/*33/-+.=.3+.=.33+3/3^-+.33*3+33/-+=3*.33/-+.
==Interpreter==
Try it online!
3 Bits, 1.5 Bytes

3 Bits, 1.5 Bytes is an assembly language for a 3-bit CPU, made by User:MihaiEso. With 1.5 bytes of memory, this machine could store at least 2 instructions.
== Operations ==
The following are instructions of 3 Bits, 1.5 Bytes:
Code	Name	Description
000 	NOT 	do NOThing.
001 	ACT 	
From	To 	
000 	111 	
001 	110 	
010 	101 	
011 	100 	
100 	011 	
101 	010 	
110 	001 	
111 	000 	
The instruction pointer can wrap around, thus allowing more "complicated" programs.
== Programs ==
The memory is 12 bits, so you can store with ~2 characters.
For example:
 0�
becomes:
 001100001011
which, when disassembled, becomes:
 ACT 100b
 ACT 011b
== Example codes ==
=== XOR 4 and 6 and print the result ===
ASCII:
 ³�
Binary:
 101100110111
Disassembled:
 XOR 100b,110b
 END
=== NAND 7 and 3 and print the result ===
ASCII:
 Ý�
Binary:
 110111011111
Disassembled:
 NAND 111b,011b
 END
== Interpreters ==
TODO...
== See also ==
* 3 Bits, 3 Bytes
Category:Joke languages
Category:Low-level
Category:Unusable for programming
Category:Unimplemented
Category:Self-modifying
Category:Output only
Category:2024
Category:Binary
Category:Languages
3 Bits, 3 Bytes

3 Bits, 3 Bytes is an assembly language invented by User:None1 for a 3-bit CPU. It is inspired by 2 Bits, 1 Byte.
==Commands==
Command (Binary)	Command (Disassembled)	What it does
000 	NOP 	Do nothing (a NOP)
001 	TEM 	TErMinate the program
010 	OUT 	Given a 3-bit value x after it, OUTput the x-th byte. (If x>=3, it does nothing)
011 	INP 	Given a 3-bit value x after it, INPut the x-th byte. (If x>=3, it does nothing)
100 	INC 	Given value in memory, INCrease given value (wraps)
101 	JMP 	JuMP. Jump (unconditionally) to address specified.
110 	CJM 	Conditional JuMp. Given two addresses, if the value in the first address is nonzero, jump to the second address
111 	NEG 	NEGate given address, formally, if its value is x, let it be 7-x
The instruction pointer can wrap around, thus allowing more "complicated" programs.
==Programs==
Since the memory is 3 bytes, you can represent the entire program with just 3 characters.
For example:
 AB@
becomes:
 010000010100001001000000
which, when disassembled, becomes:
 OUT 000b
 OUT 100b
 TEM
 TEM
 NOP
 NOP
Which outputs .
==Examples==
===Quine===
 A�
In hex dump:
 41 14 88
Disassembled:
 OUT 000b
 OUT 001b
 OUT 010b
 TEM
 NOP
===Partial Truth Machine===
 010 010 110 111 000 001 000 00n
Where n is replaced with the input (1 or 0), the zero input program Kp@ prints @ once, while the one input program KpA prints A infinitely.
Disassembled:
 OUT 010b
 CJM 111b 000b
 TEM
 NOP
 NOP (zero input)/TEM (one input)
===Output any character===
 Hÿ?
Where is replaced with the character you want to output.
Disassembled:
 OUT 010b
 TEM
 ...
The ... part is ommited because it largely depends on the character you want to print and will not be executed because of the TEM command.
==See also==
* 2 Bits, 1 Byte
* 4 bits, 8 bytes
* 5 Bits, 20 Bytes
* 3 bits, unshackled
==External resources==
* Interpreter in Python
Category:Languages
Category:Joke languages
Category:Self-modifying
Category:Implemented
Category:Binary
3 bits, unshackled

3 bits, unshackled is a language kinda like the previous ones before it, primarily 2 Bits, 1 Byte and 3 Bits, 3 Bytes.
== Commands ==
 000 - don
 001 - act (done on first 2 bits only)
 010 - jmp
 011 - prt (print)
 100 - inc (increment)
 101 - dec (decrement)
 110 - flp (flip)
 111 - end (and print)
If a command is cut off, its end is padded with zeroes.
== Infinite loop ==
 010001
== Quine ==
 111
Another one,
 011
Yet another one,
 000111
Finally,
 011000
=== ASCII quine ===
 01111101
And another
 0001111
This one is a letter
 01111100
Finally
 0000110
Funny thing, this is called "acknowledgement"...
== Something that prints something else ==
 110111111
Prints:
 110000111
== Something that prints without a print command ==
 001101
There are no print commands here. Yet, it prints.
Another one,
 101101
A third one,
 100101
== Repeating quine ==
 011010001
== Truth Machine..? ==
 011?1?
If you input 0:
 011010
 011010
 011010
 ...
If you input 1:
 011111
== Weird go-through machine ==
 011100000000010001
This does something very weird. Also, special JMP wrapping means by the second time you reach the end of the second time around, it goes to the 3rd place.
This is very weird, and acts strange.
== Jumping out-of-bounds ==
 010111
This jumps to a position 7. There are only 2 positions.
This, therefore, crashes any machine running this, with an actual 3 bit CPU.
== More to explore ==
You can find more!! :D
Category:Languages Category:Low-level Category:Output only
3 bytes :v)

3 bytes :v) is similar to 25 bytes o: and 16 bytes :P but shorter
==Description==
No matter what progam is it it will output "a"
==Quine==
 a
==Interpreter==
It's 3 bytes long! written in Inputfish
 ioa
==See Also==
* 1⅞ bytes :3
An interpreter written in Python 3
Category:Languages Category:Unusable for programming Category:Total Category:Low-level Category:Output only
3switchBF

3switchBF is yet another brainfuck equivalent, in the form of a Turing tarpit, conceived then neglected by User:Bataais in August of 2013. Because of this, information beyond the general idea may not be accurate.
==Instructions==
Each BF command is represented with 3 switches: A, B, and C. Each switch can be toggled on or off. All 8 possibilities of the 3 switches represent the 8 BF commands. E is then used to run the switch configuration as a BF command.
A 	B 	C 	BF Equivalent
OFF	OFF	OFF	>
OFF	OFF	ON 	<
OFF	ON 	OFF	+
OFF	ON 	ON 	-
ON 	OFF	OFF	.
ON 	OFF	ON 	,
ON 	ON 	OFF	[
ON 	ON 	ON 	]
Instruction	Action
A 	Toggles the A switch.
B 	Toggles the B switch.
C 	Toggles the C switch.
E 	Executes the BF instruction the switches represent.
== Examples ==
=== Cat ===
 ABEBEBCEBE
== Translator to brainfuck ==
Written in Python.
 def translate(code):
 d = "><+-.,[]" ; r = ""
 a = b = c = 0
 for cc in code:
 if cc == "A": a = 1 - a
 elif cc == "B": b = 1 - b
 elif cc == "C": c = 1 - c
 elif cc == "E": r += d[a & (b << 1) & (c << 2)]
 return r
Category:Languages
Category:2013
Category:Brainfuck derivatives
Category:Turing complete
Category:Turing tarpits
Category:Implemented
3x

3x is a stack-based esolang. It is inspired mainly by 1+ in that 3 is the only literal. Stack items can be any rational number.
== Commands ==
Command	Meaning
3 	Pushes 3 to the stack
x 	Pop A, B, and C, and push (A-B)/C
? 	Push 1 number from input
! 	Pop and print top of stack
v 	Pop A and B, store A in variable B
^ 	Pop A, push value of variable A (3 if unassigned)
# 	Swap top 2 items
(...) 	Loop while top value isn't 0 (like BF [])
[...] 	Print ...
== Examples ==
Hello World
 [Hello World]
Truth Machine
 ?([1])[0]
Multiply 2 Numbers (Note: Potentially incorrect, see discussion)
 ??3#v3333x3x3333x3x3^x(3#v3333x3x3333x3x3^x#3#v3^3^(3#v3333x3x3333x3x3^x#3#v3333x3x33333xx3^x#)#)!
== Implementations ==
A Ruby interpreter by User:Bangyen.
Category:Languages
Category:Implemented
Category:Turing complete
Category:Stack-based
4-list

4-list is a simplification of I/D machine(actually being only 1-commanded, and it supports I/O).
==Syntax==
It only works when the alphabet number is 4.
If the word doesn't end in "!" : Increment the bit pointed.
Else : Print the bit pointed as ASCII character. Jump to the byte numbered as the bit pointed.
As a loop, it is already in an infinite loop.
==Conputational class==
It is Turing-complete, since equivalence to I/D machine.
==Example==
Hello,world
Category:Languages
Category:Turing complete
Category:2018
Category:Unimplemented
4004

4004 is a simpllified Intel 4004 microprocessor architecture invented by User:A that does not involve ROM manipulation.
== Reference ==
Register groups：
Name	Size ( Bits )
Accumulator(AC or A)	4
Index Register(IR)	8
Program Counter( PC )	12
Stack Pointer( Stack )	12×3
Instruction set:
HEX	Mnemonics	Instruction word	Function
0	NOP	0000	None
1	CLB	0001	AC=0
2	IAC	0010	AC=AC+1
3	CMA	0111	AC=~AC
4	RAL	0100	Cyclic Left shift 1 bit{AC}
5	RAR	0101	Cyclic Right shift 1 bit{AC}
6	DAC	0110	AC=AC-1
7	JIN	0111	Jump to address stored in register R unconditionally.
8	INC	1000	R=R+1
9	ADD	1001	AC=AC+R
A	SUB	1010	AC=AC-R
B	LD	1011	AC=R
C	XCH	1100	Swap AC and R
D	JMS	1101	Jump to address stored in register R unconditionally, and preserve the original address into the stack SP.
E	ISZ	1110	Increment register R by 1, if the result is nonzero, jump to address A in ROM.
F	BBL	1111	Return via the stack address,AC=R
Category:Languages Category:Low-level Category:Unimplemented Category:2019