TAU800B Super: the timetravelling mainframe
The TAU800 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 “retrofuturist” 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 TAU800B Super.
The display, for example, is pure Japanese Y2K aesthetics, with flashing bright colours and a futurist typeface, looking straight out of a 90s scifi movie, but the specs of this machine are more reminiscent of an ancient 60s–70s mainframe, like the PDP1, with its esoteric word width and very limited memory. The peripherals are obsolete as well (programs are loaded via an actuallyfunctioning punchedcard!).
The computer also includes a manual typical of eras before the internet, where hardcopy manuals were comprehensive and essential for everyday use. It was clearly wellused as it contains many handwritten annotations and has even had coffee spilled on one of the pages.
However, TAU800B Super goes beyond that. Upon reading the manual, we see multiple matteroffact allusions to the “temporal computing” capabilities of the machine, or the “NovikovTuring selfconsistency 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 selfconsistency principle, which attempts to resolve timetravel paradoxes by simply saying that timelines which are not selfconsistent 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 timecone (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 timeassisted 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 ofa
two seconds before, the very value which has been used to calculateb
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 wherea
andb
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 timetravel aspects (internally, whenever it encounters instructions which refer to another point in time, it searches for a fixedpoint 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