Kkipple

Kkipple is a close derivative of the stack-based language Kipple. The idea of making a derivative came when User:Koen tried to write an interpreter, then realized it was as far from the specifications as was possible to be. The name is pronounced like stuttering the word "Kipple".

A program in Kkipple is a succession of stack identifiers, numbers, and operators.

Operators
Kkipple has six operators to handle stacks, plus two to control the execution flow. Operators take one or two arguments, which can be either stack identifiers or values. Operators are infix, so the right argument of an operator may double as the left argument of the next operator. The two operators  and   behave similarly.

The two operators  and   are equivalent, save for the inversion of their arguments.

Unary operators  and   are applied to all stack identifiers that immediately precede or follow them without being separated by whitespace:   will trigger s only,   will trigger t only, and   will trigger s first, then t.

Values and stack identifiers
A value is either a positive integer number or a stack identifier. In case of a stack identifier, the top value is popped and used as the value. For instance, if a = [1, 3] and b = [2], then:
 * will result in a = [3] and b = [1, 2]
 * will result in a = [3, 3] and b = []
 * will result in a = [4]
 * is a no-op if a is not empty, and otherwise pushes one 0 onto a.

Stack identifiers can be any string containing the characters a-zA-Z@&_ exclusively. Numbers are written in decimal. The string "0" is an exception, as it is both the number 0 and the identifier for the null stack. A number can also be expressed as a single char between single quotes, which is equivalent to the ASCII value of that char: for instance  and   are synonyms.

Whitespace in a program are usually ignored, but are forbidden inside of stack identifiers and numbers; they can thus act as separators.

If a stack is empty, then for all matters its top value is considered to be 0. It is to be noted, however, that the stacks a = [0] and b = [] are not equivalent: for instance  is an infinite loop but   is a no-op.

Double quoted strings
Similar to the "string preprocessor" in the original Kipple interpreter, double quotes can be used in Kkipple to express strings. Strings are meant to be used with operators  and. Whether strings can be used as values for other operators is unspecified. In particular,  will output Hello, whereas   will output olleH. This is the only situation where  and   are not equivalent.
 * is equivalent to
 * is equivalent to

Comments
Any value not next an operator is a no-op; however, some implementations might be slowed down from evaluating them. The proper way to write comments is using the symbol : everything to the right of a   is ignored until the next newline.

Special stacks
Some identifiers are reserved for special stacks.

Triggering special stacks
The operator  can be used to trigger special stacks. The effect depends on the stack triggered:

Example programs
Due to the lack of an interpreter, these examples might not have been tested yet.

Hello, World!
"Hello, World!">o*

Cat program
io? (o* io?)

Truth-machine
This program is very similar to its Kipple equivalent, but it actually works since Kkipple adds interactive I/O. io>a-'0' a? (a '1'>o*) '0'>o*

Fibonacci sequence
a<0 b<1 (a+b>c a>b o<a<c *o<' ')

Computational class
Kkipple is Turing-complete; any brainfuck program can be translated into an equivalent Kkipple program as follows, using two stacks prev and next to emulate a left- and right-unbounded tape.

Implementation
The language has only recently been created, and is subject to changes. An implementation will be provided once it is more stable. Meanwhile, suggestions as to how to improve it are welcome!