The TAU-800 series is a fantasy computer originally conceived for an interactive art exhibition on the theme of “anachronism”. I developed it together with Miguel Murça.

Originally, when we were challenged to build a piece related to the theme of anachronism, we decided to invent a fantasy computer which mixed and matched the aesthetics from different eras. More than that: we wanted to evoke the conceptions of futurism from different eras.

Often, a “retro-futurist” aesthetic is as memorable as the actual aesthetic of the technology from a certain era. For example, technology from the 1960s has a very distinctive look, but the aesthetics of science fiction from that decade, from Star Trek to 2001: A Space Odyssey, are often even more memorable than the technology of that time period itself.

We’ve incorporated this into the visuals of TAU-800B Super.

The display, for example, is pure Japanese Y2K aesthetics, with flashing bright colours and a futurist typeface, looking straight out of a 90s sci-fi movie, but the specs of this machine are more reminiscent of an ancient 60s–70s mainframe, like the PDP-1, with its esoteric word width and very limited memory. The peripherals are obsolete as well (programs are loaded via an actually-functioning punched-card!).

The computer also includes a manual typical of eras before the internet, where hardcopy manuals were comprehensive and essential for every-day use. It was clearly well-used as it contains many hand-written annotations and has even had coffee spilled on one of the pages.

However, TAU-800B Super goes beyond that. Upon reading the manual, we see multiple matter-of-fact allusions to the “temporal computing” capabilities of the machine, or the “Novikov-Turing self-consistency principle”. Digging a bit more, we soon understand that this machine is anachronistic in more ways that one: the CPU can literally travel through time: its instruction set lets us not only read from/write to a register or an address in memory at the current time, as any computer does, but also read values from the future or write values to the past! By perusing the manual, one also gets the sense that this is a relatively commonplace technology in the alternate reality to which the machine belongs, notwithstanding the remaining technology being that of the 1970s or earlier.

This takes inspiration from the Novikov self-consistency principle, which attempts to resolve time-travel paradoxes by simply saying that timelines which are not self-consistent are unphysical and cannot exist. Closed timelike curves and time travel are allowed, if and only if no event is a cause of a change in its past time-cone (see e.g. Polchinki’s paradox).

This extraordinary technology enables it to complete tasks in an impossible amount of time, since it can bend time to reach into the future and retrieve an answer which has not yet been calculated, and use it to produce the value which itself will have been read when the world reaches that point in the future (does your head hurt yet?). However, great care must be taken to ensure that the execution of the program does not create any temporal inconsistency events (the manual is filled with warnings and disclaimers of liability to this effect)!

To see a quick example of time-assisted computing in action, take a look at how we might calculate the square root of a number using Newton’s method.

def sqrt(x):
	a ← x / 2
	b ← (a + x/a) / 2
	while b ≠ a:
		a ← b
		b ← (a + x/a) / 2
	return a

Looks simple: start with a guess (in this case half of x), and update the guess using Newton’s rule. Repeat until convergence.

Now look at how we might do it if we have a machine that can write values to the past!

def sqrt(x):
	# t = 1s
	a ← x
	# t = 2s
	b ← (a + x/a) / 2
	# t = 3s
	a @ 2s ← b
	# t = 4s
	return a

That is: we

• (at t=1s) calculate (any) initial guess a,

• (at t=2s) do one step of Newton’s method on it, obtaining b, and

• (at t=3s) the crucial step, we take this improved guess b and write it to the value of a two seconds before, the very value which has been used to calculate b itself! Of all the possible timelines, the only one which does not result in a paradox, and therefore the one that is physically realised, is one where a and b are exactly the same: but this is precisely the convergence condition of Newton’s method.

Et voilá, we’ve computed the square root of a number in constant time, in 3 instructions only! 😊

In terms of implementation, the backend is written is Rust, and faithfully emulates the fictional machine, including its time-travel aspects (internally, whenever it encounters instructions which refer to another point in time, it searches for a fixed-point of the evolution of a finite window of time around the current moment, seeing as time travel is limited to ±31 clock cycles in either direction). The frontend was done with a collection of web technologies.

Check the manual and the cover video of the piece we showed.

As a bonus, here is the actual snippet of code used for calculating a square root in one iteration, in our fictional machine’s assembly language ;)

; Input and output: register `a`
sqrt:
    ; Initial guess: b = input / 2
    mov a bl
    lsr bl

    ; Corner cases: √0 = 0, √1 = 1
    bne sqrt.continue
    ret
    sqrt.continue:

    ; Improved guess: c = (b + input / b) / 2 
    mov bl cl  ; c = b
    mov a bh
    div bl bh  ; b = a/b
    add bh cl  ; c = b + a/b
    lsr cl     ; c = (b + a/b) / 2

    ; c = min(b,c), needed for corner case where input is 
    ; 1 less than a perfect square
    cmp bl cl
    bmi +2
    mov bl cl
    bne +2  ; Needs these nop to ensure same time of 
    nop     ; execution of both branches, and thus 
    nop     ; avoid temporal inconsistencies.

    ; Put back the improved guess as the initial guess
    mov cl bl@-10

    ; Return result through a
    mov bl a
    ret