Quiney

Quiney is a tape programming language, like BF (Both in commands and style), whose variable system and commands are stored on the same, one-dimensional, infinitely long (in one direction) array, which can store the numbers 0 through 9. These numbers, for human readability, are actually commands that are commonly written as their representative characters. The commands in Quiney are as follows:

The selected cell in the initiation of any program is the first. This allows for the one command, one character quine,

Interpreter Regulations
Besides past stated regulations, when a program runs, the only errors that should come up are a wrong number of close brackets trying to be executed. If extra brackets exist, but are behind or in front of the program and wont be executed, there need be no error. For example, the below program should run because the end bracket is never read. Programs who create brackets which aren't read are also OK. If a command moves the data cursor past the last command, a new command is made, and set to. "+[*]]" When a  is executed, the interpreter should ask for a value, 0 through 9 (representing a command) or any command character.

Cellular Automaton
Quiney could be used as cellular automaton, mainly because it can systematically edit itself (by it's own rules).

Examples
Code is surrounded in quotes, to preserve the visibility of the space character.

Quines
The One Command Quine "."

Quine-Six Char. ".[}.] "

Eight Char. ".}[.}]. "

'''Eight Char. Quine With Two Null''' " .+[}.] "

Six Char. "[.}]. "

Seven Char Quine ".[}.]} "

An n + 7 Quine ".[}.]}" (Repeating "}" or "{" can be inserted here) " "

Self Modifying
These programs self modify, morph, or destruct

Self Destruct (one Char) "*"

Self Mutating program "[ }]}[}]+[{]+[}[-]+] " Which gets stuck in an infinite loop state, oscillating between the two states below: "[[[[[[[[[[[[[[-]+" "[[[[[[[[[[[[[ -]+"

Oscillators
only the first phase can be executed, the rest are visuals of the code state, their pointers aren't at cell 1.

Small Oscillator, 2 phase "[-]+" -other phases " -]+"

Midsize Oscillator 4 phase "[ }}[}]++ [-][{]]" -other phases "[ }}[}]++-][{" "[ }}[}]+++[-][{]]" "[ }}[}]++.[-][{]]"

Interpreters
You Decide (Simple, almost useless interpreter) The smallest interpreter, possibly ever. Fragile. "[}]}[ ,]" This has two useable, reasonable commands, "-", possibly a wait, turns into a "," and a "," which asks for another input. A space would knock the program into infinite loop, and the "*" would do the same after the equivalence of one wait. A close bracket would also loop infinitely after a period of one wait. An open bracket would cause an almost instant error. "." would cause an infinite output of itself, which could be considered a quine, and a "+" would turn into a "." and continue outputting "."s "{" would move the cursor to a null, causing the loop to stop and the program to end. "}" would eventually move the cursor to a null character and end the program.

More Complex Interpreter Has different "Phases", initial program is Phase 1, other phases can be entered with certain commands. "[}]{[}, {]" - ---Phase 1--- Program will continue to take input after each command unless otherwise noted. Null does nothing. "[" Creates error. "," Asks for another input, but does nothing, possibly a "Skip next command". "-" turns itself into a "," but doesn't ask for input, does nothing. A "." prints a "." to the output. A "+" turns into a ".", but does nothing. A "]" Moves program to phase 2. When a "*" is entered, it uses up one rotation. "{" delays the interpreter one rotation. "}" puts the interpreter into phase 3. - ---Phase 2--- Almost a perfect self interpreter program (For Quiney)! Once the "]" has been entered to get to this phase, one can enter a Quiney program with only a few specific rules. As long as there are no spaces in the Quiney program being inputted, one can simply type it in, and end it with a null character. For example: "][.}]. " can be typed in from the beginning of this interpreter to execute the Quiney program: "[.}]. " - ---Phase 3--- A "{" Will put the interpreter into stage 4. A "}" will end the interpreter. A "[" will cause an error. When a "]" is entered, interpreter enters phase 5. - ---Phase 4--- A "]" must first be entered, else the program will crash. After the program receives this, it enters phase 2. Although the actual code being executed is different, the interpreter after the close bracket in Phase 4 and in Phase 2 are essentially the same. - ---Phase 5--- This description is a WIP.

Computational class
Quiney is Turing complete, as brainfuck with decimal digit cells can be reduced to it.