:..: (colon period period colon) is an esoteric programming language based on the manipulation of four unbounded integer registers.

A program in :..:

1. Consists only of the symbols : (colon) and . (period); all other symbols are ignored.
2. Is a sequence of 4-tuples that form program instructions (the program length % 4 == 0).
3. Has a length greater than zero (at least one 4-tuple).

Each 4-tuple reads or manipulates one of the four registers A, B, C, D.

The current register is determined by the index of the instruction in the program code. For instance, the first instruction works with A, fourth with D, fifth with A, and so on.

Four possible instructions can be formed based on the position of the colon in a 4-tuple:

Instructions [ and ] are paired, meaning each [ must have a following ] and vice versa.

Instructions can be combined into compact ones. For instance, the 4-tuple ::.. contains both instructions [ (loop begin) and + (increment). Compact instructions are executed in the order they appear in the 4-tuple.

Does nothing:

....

Loops forever:

:..:

Alternativelly:

::::

Sets register A to zero:

.... .... :... ....
:... .... .:.. ....
.:.: .... .... ....
..:: .... ..:. .... 

The program reads as follows:

C[ A[ C+ A+] A-] C-

Moves register B to register A:

.... .... :... ....
.... :... .:.. ....
.... .:.: .... ....
.:.. ..:. ...: ....
..:. ..:. ..:. ....

The program reads as follows:

C[ B[ C+ B+] A+ B- C] A- B- C-

Copies register A to register B:

.... .... :... ....
:... .... .:.. ....
.:.: .... .... ....
..:. .:.. .... .:.:
.... ..:. ..:. ..:.
.... .... :... :...
.... .... .:.. .:.:
.... .... .... ..:.
.:.: .... .... ....
..:. .... ..:. ....

The program reads as follows:

C[ A[ C+ A+] A- B+ D+] B- C- D- 
C[ D[ C+ D+] D- A+] A- C-

Switches register A with register B:

.... .... :... ....
::.. .... .:.: .:..
..:: .... ..:. ..:.
.... .... :... ....
.... ::.. .:.: ....
.:.. ..:: ..:. ....
..:. .... :... ::..
.... .... .:.: ..:.
.... .:.: ..:. ....
.... ..:. .... ....

The program reads as follows:

C[ A[ A+ C+] D+ A-] C- D-   move A to D
C[ B[ B+ C+] A+ B-] C- A-   move B to A
C[ D[ D+ C+] D- B+] C- B-   move D to B

Computes the sequence in register A:

.... .:.. :... ....
.... .... :... ....
::.. .... .:.: .:..
..:: .... ..:. ..:.
.... .... :... ....
.... ::.. .:.: ....
.:.. ..:: ..:. ....
..:. .... :... ::..
.... .... .:.: ..:.
.... .:.: ..:. ....
.... ..:. :... ....
::.. .... .:.: .:..
..:. .:.: ..:. ..:.
.... ..:. :... ::..
.... .... .:.: ..:.
.:.: .... ..:. ....
..:: .... .... ....

The program reads as follows:

B+                              init 0 1 0 0
C[                              loop forever
    C[ A[ A+ C+] D+ A-] C- D-   move A to D
    C[ B[ B+ C+] A+ B-] C- A-   move B to A
    C[ D[ D+ C+] D- B+] C- B-   move D to B
    C[ A[ A+ C+] D+ A- B+] C- D- B- 
    C[ D[ D+ C+] D- A+] C- A-   copy A to B
]

For computing "Hello World," we need to interpret integers in registers as a string. We can achieve this by defining an alphabet and concatenating register values.

Registers must contain the following values:

Shortened code:

.:.. .:.. .:.. .:..     33 times
.:.. .:.. .:.. ....    179 times
.... .:.. .:.. ....     84 times
.... .... .:.. ....    198 times

:..: is intuitively Turing-complete as it provides four unbounded registers (two have been proven to be sufficient), elementary arithmetics, and while loops.

A concrete proof is still to be done.

npm i cppc

const cppc = require('cppc')

// [2, 0, 1, 1]
cppc(`.:...:...:...:...:....:.`)

MIT