Somewhere at the bottom of the Forth and Clyde Canal, buried in the silt, there is a box of custom silicon that was right about almost everything.

Back in 1988 a Scottish hi-fi company shipped a processor that checked the type and bounds of every memory access in hardware, garbage-collected its own heap in silicon, and treated memory and disk as a single persistent object store. Retellings of the story make it out as charming folly, one where a company that made record turntables decided von Neumann was wrong.

But the story of the Rekursiv deserves to be more than just a curiosity, because almost forty years after it went into the water, its ideas are now shipping in production silicon from Arm; and also because the economics that killed it have just been reversed. Although all these years later, the fine details of the story mostly rest on the recollections of people who were there, it turns out that the hi-fi company were right about almost everything except which decade to build the hardware.

A hi-fi company builds a computer

Linn Products is the Glasgow company Ivor Tiefenbrun founded in 1972, and if you know it at all you know it for the Sondek LP12, still widely regarded by its partisans as the finest record deck ever made.

By the early eighties Linn had built a modern factory at Eaglesham, south of the city itself, and ran their business on a pair of VAX-11/750s along with a pair of 11/780s. But Tiefenbrun came to loathe the software they used. He wanted a system in which every physical object in the factory, down to each individual turntable moving through assembly, test, and even after-sales, had a shadowing software object accumulating its history (Pountain, Byte, November 1988).

So around 1981 Linn hired programmers and a University of Glasgow computer science lecturer, David Harland, and built an object-oriented language called LINGO. LINGO was a Smalltalk with some Algol in its syntax, not to be confused with the other Lingo programming language, which wouldn’t come along for another eight years.

MICRO$COPYTREE: entf 1 pagebus d=ustack
    crtf IDXBADTYPES newtrbr _CONS
    incmsp m.sp' newmptr
    jf MICRO$COPYTREE ldustk d=pgrorr     // the CDR branch
    m.fp 1 uaddbr newmptr
    readustk
    pagebus d=ustack
    idx2 newsr newbr loadaddr
    idxget nocheck incmsp m.sp' newmptr
    jf MICRO$COPYTREE ldustk d=memout     // the CAR branch
    js RTN$CONS
    rtf

Microcode for a recursive tree-copy instruction. Note the instruction calling itself, something forbidden to a conventional CPU (Source: Pountain, 1988).

LINGO worked; but it also ran far too slowly on the VAX to automate anything. Tiefenbrun’s response was pure Tiefenbrun. The hardware was the problem, not the software: so Linn would build hardware.

While stranded on a delayed train home from a seminar, Harland, and another computer engineer Bruno Beloff, sketched the repartitioning of their prototype into custom chips they christened “Rekursiv,” which is why Harland later joked that “the Rekursiv [was] British Rail’s fault.”

A few years later, in 1984, Tiefenbrun formed Linn Smart Computing, installed his brother Marcus as managing director and Harland as technical director, and funded it with Linn’s own money plus roughly £10 million from the Department of Trade and Industry.

LSI Logic fabricated the chips. Four gate arrays in 1.5 micron CMOS, 299 pins each, named NUMERIK, LOGIK, OBJEKT and KLOK. A company that sold the Sondek, the Ittok, and the Asak was never going to name the chips anything else.

Objects all the way down

What made the Rekursiv strange was not that it ran object-oriented programs. It was that a programmer – or, come to that, the compiler – could never see an address. Every object carried a 40-bit number issued at creation, and the OBJEKT chip translated numbers to physical locations through a hashed pager table, checking the type and the bounds of every single access in hardware as it went. Run off the end of an array? The machine refused. Forge a reference? The machine refused. Since only OBJEKT ever knew where anything physically lived, objects could be relocated freely without touching a reference, so garbage collection went into the silicon too: a two-space compacting collector that walked the live objects and slid them into the other half of DRAM while execution carried on above, oblivious.

Persistence worked the same way. Memory and disk were one object store, and if a needed object wasn’t in DRAM the processor simply stalled, mid-instruction, while an external disk processor fetched it, then carried on as if nothing had happened. Because paging sat below the level of instruction execution, a single microcoded instruction could be arbitrarily complex, and could even call itself. That’s the recursion in the name. There was no fixed instruction set at all; the instruction set was a loadable artefact, and you gave the machine whichever one suited your language. Linn supplied C, James Lothian microcoded a Prolog instruction set, a Manchester group put Scheme on it, and Aberdeen ported the persistent language PS-algol. I am a St Andrews alumnus who was around at the right (or if you want to look at it like that, the wrong) time. I can still remember more than I’d want to about PS-algol. But that, as they say, is altogether another story.

The numbers Linn claimed were spectacular. A CONS cell every two microseconds, twenty times the speed of Lisp on a Symbolics workstation, and Prolog unification as a single instruction. But the figures came from Linn’s own simulations, reported in Byte magazine with the company’s cooperation, and nobody ever reproduced them independently.

The attack of the killer micros

The Rekursiv belonged to a respectable intellectual tradition. Through the seventies the industry consensus held that hardware should rise to meet the language, closing what the literature called the semantic gap; Intel bet its first 32-bit design, the object-oriented iAPX 432, on exactly this, and Symbolics built a workstation business on Lisp in microcode.

Unfortunately for the Rekursiv that tradition was demolished in public at almost the exact moment Linn committed to it. Patterson and Ditzel made the case for RISC in 1980: compilers use a fraction of a complex instruction set, the complexity taxes the common case, and simple instructions plus caches plus good compilers go faster. By 1984 Berkeley’s SOAR project had run Smalltalk, the canonical dynamic object language, fast on a simple chip of thirty-five thousand transistors. The Rekursiv’s central assumption was publicly undercut four years before the first board powered on.

Then the economics arrived. Commodity microprocessors improved at roughly 52% a year from 1986 to 2003, the period Eugene Brooks of Lawrence Livermore christened the attack of the killer micros. The Rekursiv took four years to design. It was conceived when a VAX defined respectable performance, and in 1988 it emerged into a world of SPARCstations and 386s, with the 486 arriving close behind.

Lothian, who was there, put it plainly enough five years later: the machine simply couldn’t hold its own against the new workstations. Around twenty or thirty boards were built. Most went to universities. There’s no record that suggests one of them ever ran Linn’s production line, which was the entire point of the exercise. The one field comparison that survives has a threaded-code LINGO on a Sun-3 running about twice as fast as the Rekursiv board it was meant to be inferior to, and which was designed with the intent of running it.

The end was memorably Glaswegian. Black Monday had squeezed Linn’s finances, a venture rescue never closed, and the final straw was a car park. A Linn delivery driver reversed a van into Harland’s Porsche, Tiefenbrun declined to pay for the repair on the grounds that it happened on private ground, and Harland resigned.

On his way out he threw his own accumulated hardware and backup media into the Forth and Clyde Canal. The version of the story where the whole product line goes into the water is better; but the truth is good enough.

At least one complete board escaped, and sits today in the Jim Austin Computer Collection near York.

Linn, meanwhile, recycled the name Numerik for the DAC in its CD range, which is as good a headstone as any. Harland left computing entirely around 1995 and became one of the most prolific historians of spaceflight, several dozen books and counting. As a recovering astronomer myself, I can only approve of the career change.

Right about everything?

But here is why this is all more than an historic anecdote. Because I think we need to take a hard look at the Rekursiv’s four defining design decisions, and then ask where each one stands today.

Hardware memory safety

OBJEKT checked the type and bounds of every access against references the program couldn’t forge. That’s a working description of CHERI, the capability architecture Robert Watson and colleagues have been building at Cambridge and SRI since 2010, in which every pointer carries hardware-enforced bounds, permissions and an unforgeable validity tag.

Arm built it into the Morello prototype boards it shipped in 2022 under the UK’s Digital Security by Design programme, and ships the lighter-weight Memory Tagging Extension in Android phones today.

Microsoft’s security team concluded in 2020 that CHERI would have deterministically mitigated at least two thirds of the memory-safety vulnerabilities it patched in 2019. The idea that the object, with its type and its bounds, is the proper unit of hardware protection has gone from eccentric to frontier.

Garbage collection as an architectural concern

Azul Systems spent the 2000s selling Vega appliances, custom multicore processors with hardware read-barrier support, to make pause-free collection practical for Java heaps; the C4 collector that came out of that work now runs in pure software on commodity x86. The algorithm survived the move; the custom silicon stayed behind.

The single-level persistent store

IBM shipped single-level persistent stores in the System/38 in 1978, carried it through the AS/400, and it survives today as IBM i; Intel spent billions trying to reboot the idea as Optane before winding it down in 2022, and the same ambitions are now migrating into CXL memory fabrics. An idea the market keeps finding reasons to want, and reasons not to pay for, is different from a bad idea.

Silicon shaped to a workload rather than to everything

This is the biggest design decision: the one that is now just the way the industry works. Hennessy and Patterson, the two people most responsible for burying machines like the Rekursiv, spent their Turing Lecture arguing that domain-specific architectures are the only road forward now that Dennard scaling is dead and Moore’s Law is wheezing. Or to be more honest, also dead.

Google’s TPU, Groq’s deterministic streaming processor, Cerebras’s wafer-scale engine and Etched’s transformer ASIC are all machines built to run one computational language well; it just happens that the language is now linear algebra rather than Smalltalk.

Four for four

Every architectural conviction that went into the canal with the Rekursiv is either shipping, in production, at scale, or is the declared direction of an entire field. Four correct calls in a row is too many for luck. The likelier reading is that the almost forty years in between were not the natural state of computing but an accommodation to a scarcity, and that the scarcity has since gone away.

I made a different version of this same argument back in June, about software rather than silicon. In my essay a distribution of one I argued that bespoke software was the original, correct arrangement, that fifty years of productised general-purpose software were a compromise forced by the economics of scarce programmers, and that AI has ended the compromise.

The general-purpose commodity processor was also a compromise, forced by a 52%-a-year improvement curve that made any bespoke architecture obsolete before it reached silicon. That curve is gone. The compromise is going with it; and the workload-shaped machine, the thing Harland was building in 1984, is what comes back.

Where the semantics live

The comfortable lesson, and the one usually made about the Rekursiv, is that you don’t fight the commodity curve. This is true, but no longer very useful, because the curve is dead. The useful lesson is subtler, and you can see it when you think about why IBM succeeded with the same ideas at the same time.

The System/38 had the Rekursiv’s deepest commitments: single-level store, persistent objects addressed by name rather than address, capabilities, everything an object. It thrived for decades because IBM put those semantics in a virtual instruction set, the Technology Independent Machine Interface (TIMI), and translated to whatever processor was underneath. When the platform moved to PowerPC in 1995, customer applications didn’t even need recompiling. Linn welded the same semantics into four specific gate arrays. The abstraction is still running today; the gate arrays lasted five years.

Interestingly enough, Britain has run this experiment more than once, but with very different outcomes.

Acorn, another small British company with contrarian silicon convictions, designed the ARM 1 in 1985; and the business that conquered the world was not Acorn’s computers but the licensing company that sold the abstraction, an instruction set anyone could implement on whatever process node the commodity curve offered next.

Inmos, meanwhile, welded David May’s genuinely brilliant parallel architecture into the Transputer, was outrun by exactly the same curve that took the Rekursiv, and survives today mainly as lineage: May’s XMOS, and Bristol’s continuing habit of contrarian silicon, through to Graphcore. Put the ideas above the silicon and they can outlive any particular chip. Put them in the silicon and they live exactly as long as the process node does.

Everyone needs a canal

The Rekursiv was hardware reshaped to fit a language, because the general-purpose machine fitted the language badly. What’s happening now is the same move in reverse: a whole class of new languages reshaped to fit a machine, because general-purpose languages fit LLMs so poorly. There are enough of them now to fill a catalogue, which I maintain at agentlanguages.dev, where they split into camps that disagree about almost everything except the diagnosis.

Vera, the language I released back in February, is mine. But the instinct underneath all of them is the one Harland was acting on in 1984: that the substrate should change to meet its authors. For him the authors were human and the substrate silicon. This time the authors are models and the substrate the language. Harland made his bet at the worst possible moment in the history of the commodity curve. I’d like to think mine is better timed. The canal is patient either way.

The second time around

Which brings us to why I’m writing about a dead Glaswegian computer.

Our thesis at Negroni has always been that technology waves are cyclical, and that reading the cycle matters more than reading the technology. The Rekursiv is the cleanest case study I know of a team that read the technology almost perfectly and the cycle catastrophically: right about memory safety, right about garbage collection, right about persistence, right about workload-shaped silicon, and wrong about what year it was needed.

The team at Linn were insanely early with a design philosophy which was, to put it politely, exotic at the time. It’s only now, all these years later, that we know they were right.

Judged on its ideas, the Rekursiv holds up embarrassingly well. It’s only judging the execution which makes every decision look wrong. But being right too early is not a business model.

The reason to tell the story now is that the cycle has actually turned. The 52% curve that killed every bespoke architecture of the eighties ended twenty years ago; RISC-V and modern tooling have collapsed the cost of taping out something opinionated; and the government money is even flowing again: DTI millions into Glasgow back then, Digital Security by Design millions into Cambridge and Morello today.

For the first time since Harland stood on that canal bank with a cardboard box full of silicon, a small team with a contrarian conviction about what silicon should do is not automatically doomed by the calendar. That’s precisely why Negroni looks at silicon companies, and when we do, the Rekursiv is the checklist I follow. Is the workload broad enough to pay for the transistors? Do the ideas live above the silicon or welded into it, and does the team know what the compilers will do to them?

Somewhere at the bottom of the Forth and Clyde Canal there’s a computer that was right about almost everything. The ideas behind it took almost forty years to make it back to the river bank, but every one of them has made it to shore. This time around, our job needs to be keeping the silicon out of the water.