TritBitJump

TritBitJump is a language which is based on BitBitJump but is also nontrivially different from that and from other WordWordJump languages. It circumvents the fixed address size problem in an unorthodox way which involves analyzing the bits in the machine as though they were trits, and is therefore more likely to be Turing complete.

Basics

The basics are actually much more similar to BitBitJump than the name might imply.

Like BitBitJump, the abstract machine operates on an infinite array of memory which consists of bits (not trits). Each bit has its own address, and addresses start from 0 like in BitBitJump.

However, unlike BitBitJump, bits are grouped into addresses in a very specific way. Instead of each bit being a number in a word, groups of two bits are used to determine both the word and the space between words. This is where the "trit" in TritBitJump comes in. The combination 00 is 0, 01 is 1, 10 is 2, and 11 indicates the space between addresses.

Three consecutive addresses in memory (A, B, C) constitute an instruction - copy the bit at address A to the bit at address B, then jump to the bit at address C and figure out the next instructions starting at that bit. If both the bit at C and the next bit are 1, then those bits are ignored. The machine looks at the two bits after those until it finds a pair of bits which aren't both 1, and that is the next address.

For example, see the following program:

1011011100110111001111101101011

The first instruction is analyzed as:

10 (11) 01 (11) 00 (11) ...

which is, in base 3:

2 1 0

Once the first instruction is done, it puts the bit at location 2 into location 1, resulting in:

1111011100110111001111101101011 / (11) (11) 01 (11) 00 (11) 01 (11)...

It starts from bit 0, but because the first four bits are 11, the new A becomes 01, the new B becomes 00, and the new C becomes 01. This instruction on its own doesn't change anything, but the jump shifts the way that the bits are read:

...(11) 10 (11) 100110 (11) 1001 (11)...

This is where another difference from BitBitJump becomes clear: TritBitJump is little-endian, because that makes it easier to jump to an arbitrary point if you don't actually know how long the number is. Therefore, this instruction is, in base 3 (little-endian) / base 10 (normal i.e. big-endian):

2 212 21 / 2 23 5

Bit 23 was 0 and now it's 1, so now it's:

1111011100110111001111111101011

and the next instructions are:

...(11) 100110 (11) 1001 (11) (11) (11) 1010 (11) | 212 21 22 | 23 5 8
1111011100110111001111111101011 (no change)
00 (11) 01 (11) 00 (11) | 0 1 0
1111011100110111001111111101011 (no change)
(11) (11) 01 (11) 00 (11) 01 (11) | 1 0 1
1111011100110111001111111101011 (no change)
(11) 10 (11) 100110 (11) 1001 (11) | 2 212 21 | 2 23 5
1111011100110111001111111101011 (no change)

You may have noticed that 2 23 5 already showed up and it didn't change anything. Therefore, the code is now in an infinite loop. Overall, this code wasn't meant to do anything, but it did show how TritBitJump works and it set up a method for conveying TritBitJump commands.