SFIN

SFIN, which stands for “Simple Four-Instruction Nand”, is a very minimalistic language which only contains four commands. This language is inspired by [Brainfuck] and the process of NAND logic.
==Language Overview==
SFIN operates on four bits at the start of the program which are all initialised to 0. However, this can be increased using syscalls by doubling (8, 16, 32…). There is also one bit of memory which is used for storage of command outputs which is initialised to 0. The standard commands are:
Command	Description
> 	Moves the pointer one bit right with overflow.
? 	Saves the bit at the pointer to memory
v 	Nands the current cell with the bit and memory and sets the cell to the result
 	Sets a pointer in the program
d 	(ONLY IN THE DEBUGGER) Prints debug info about the program. Implementation can vary from interpreter to interpreter
However, by using multiple of some of these commands, you get new commands to use:
Command	Description	 	 	
??... 	Calls a syscall for every question mark together - 1 (so 2 question marks will make 1 syscall) following this table:
{| class="wikitable"	Current Cell 	Memory	Effect
0 	0 	Doubles the length of memory 	 	
1 	0 	Sets the current cell to a value from IO (either “0” or “1”)	 	
? 	1 	Prints the current cell to IO (either “0” or “1”) 	 	
==Examples==
Due to the simplicity of SFIN, many common tasks in programming languages become much more difficult.
This simple program stores the value of Bit 1 in Bit 2
 ? Stores the value of Bit 1
 > Sets the pointer to Bit 2
 v Bit 2 = Bit 1 NAND Bit 2
 v Bit 2 is NANDed by Bit 1 again. This sequence sets Bit 2 to the inverse of Bit 1
 ?v Gets the value of Bit 2 and NANDs it with itself. (X NAND X = NOT X)
This program takes two bits as inputs and outputs the XOR of the two without using any loops. It seems likely that this could be improved using loops.
 v??>v?? Sets b[1] (the first bit) and b[2] to inputs
 >>>?>>vv?v Stores b[1] in b[3]
 >>>?>v Sets b[3] to b[1] NAND b[2]
 ?>>v>v b[1] = b[1] NAND b[3], b[2] = b[2] NAND b[3]
 ?>>>v b[1] = b[1] NAND b[2]
 >>>v? Sets b[4] to 1 for printing and saves it to memory
 >?? Outputs b[1]
A simple program using loops to simulate an increment (this program assumes 4 bits of memory
The program should start at the highest bit of the number
 | Sets a pointer for the program
 >>> Moves back one (change this if the memory is larger)
 ?v Inverts the current cell
 ? Saves the current cell
 || Jumps back if it is zero
A truth machine written in SFIN.
 v?? Sets b[1] to input
 >>>>?>vv>v Sets b[2] to !b[1] and b[3] to 1
 | Start of a loop
 ? Stores b[3]
 >>?? Prints b[1]
 >? Saves b[2]
 > Moves back to b[3]
 || Jumps to loop if zero
==Binary Representation==
SFIN can be compiled to binary by using the official Python interpreter. Each instruction is taken up by two bits following this structure:
>	00
?	01
v	10
 	11
==Computational Class==
There has been no formal proof that SFIN is turing-complete. However, it seems very possible to implement Boolfuck in SFIN, thus proving its turing-completeness.
==External Resources==
The official python interpreter
Category:Languages
Category:2023
Category:Cell-based
Category:Unknown computational class
Category:Implemented