The Computer at the Bottom of a Canal

Somewhere beneath the silt of the Forth and Clyde Canal, there lies a collection of custom silicon that was essentially a prophet. It was right about almost everything, but it was born in the wrong era.

In 1988, a Scottish company known for high-end audio equipment released a processor that featured:

• Hardware-level bounds and type checking for every memory access.
• A heap managed by a silicon-integrated garbage collector.
• A unified persistent object store that blurred the line between disk and RAM.

While some dismiss this as a "charming folly"—the idea of a turntable manufacturer deciding that the von Neumann architecture was flawed—the story of the Rekursiv is more than a trivia piece. Nearly four decades after it was dumped in the water, its core philosophies are finally appearing in production silicon from Arm.

The hi-fi company was delusional. Actually, they were right about the technology; they were just wrong about the 1980s decade.

A Hi-Fi Company's Digital Ambitions

Linn Products, founded in Glasgow in 1972 by Ivor Tiefenbrun, is legendary for the Sondek LP12—still hailed by many as the pinnacle of record decks.

By the early 1980s, Linn was operating out of a modern facility in Eaglesham, powered by a fleet of VAX-11/750s and 11/780s. Tiefenbrun envisioned a comprehensive digital twin of his factory. His goal was a system where:

• Every physical item (down to a single turntable) had a corresponding software object.
• Every stage of assembly and testing was tracked.
• After-sales history was permanently linked to the object.

To achieve this, Linn hired David Harland (a lecturer from the University of Glasgow) and a team of programmers to create LINGO, an object-oriented language that blended Smalltalk concepts with Algol syntax.

The Performance Wall

LINGO worked, but it was agonizingly slow on VAX hardware. The bottleneck wasn't the code—it was the CPU. This realization led Linn to a radical conclusion: they would build their own hardware.

While stuck on a delayed train, Harland and engineer Bruno Beloff sketched out the architecture for custom chips. Harland later quipped:

"The Rekursiv [was] British Rail's fault."

In 1984, Linn Smart Computing was born, funded by the company and a $\approx £10$ million grant from the Department of Trade and Industry.

The Architecture of the Rekursiv

The hardware consisted of four gate arrays built using $1.5\mu m$ CMOS technology. In keeping with the company's audio branding (Sondek, Ittok, Asak), the chips were given appropriately themed names:

Objects All the Way Down

The Rekursiv wasn't just "running" OO software; it was OO hardware. The most striking feature was that programmers (and compilers) never saw a physical memory address.

1. Object IDs: Every object was assigned a 40-bit unique identifier.
2. The OBJEKT Chip: This chip acted as a translator, using a hashed pager table to map these IDs to physical locations.
3. Hardware Validation: Every single access was checked for type and bounds in real-time by the silicon.

Because the OBJEKT chip handled all mapping, objects could be moved in memory without updating references. This allowed for a two-space compacting garbage collector implemented directly in silicon, which slid live objects across DRAM while the program continued to run.

Furthermore, the system treated memory and disk as a single store. If an instruction needed an object not currently in DRAM, the processor would simply stall mid-instruction until the disk processor fetched it.

Loadable Instruction Sets

The Rekursiv had no fixed ISA (Instruction Set Architecture). Instead, the instruction set was a loadable artifact. You could swap the machine's "brain" to suit your language:

• C (supplied by Linn)
• Prolog (microcoded by James Lothian)
• Scheme (implemented by a Manchester group)
• PS-algol (ported by Aberdeen)

This flexibility allowed for incredibly complex microcode. For example, a single instruction could be recursive:

// Microcode for a recursive tree-copy instruction
MICRO$COPYTREE: 
    entf 1 pagebus d=ustack 
    crtf IDXBADTYPES 
    newtrbr _CONS 
    incmsp m.sp' 
    newmptr 
    jf MICRO$COPYTREE  // <--- The instruction calls itself!
    ldustk d=pgrorr 
    // ... (further CAR/CDR branch logic)

The "Killer Micros" and the Fall

On paper, the performance was staggering. Linn's simulations claimed a CONS cell every $2\mu s$—roughly 20 times faster than a Symbolics Lisp machine. However, these figures were never independently verified.

The Rekursiv was part of a broader intellectual movement to close the "semantic gap" (the distance between high-level languages and hardware). Other giants tried this:

• Intel bet on the object-oriented iAPX 432.
• Symbolics built an entire business on Lisp-in-microcode.

Unfortunately, the industry shifted. The "killer micros"—cheap, blisteringly fast, general-purpose CPUs—began to evolve. It became cheaper to solve the semantic gap with smarter compilers and faster raw clock speeds than with complex, specialized silicon.

The Rekursiv, and the vision of Linn Smart Computing, eventually sank—literally and figuratively—into the canal.