The Rekursiv: A Forgotten Object-Oriented CPU and the Return of Bespoke Silicon

The Rekursiv: A Visionary Failure of the 1980s

The Rekursiv was a custom silicon processor developed in the 1980s by Linn Smart Computing (a spin-off of the Scottish hi-fi company Linn Products) that implemented object-oriented principles directly in hardware. While the project ultimately failed commercially and ended with its hardware being thrown into the Forth and Clyde Canal, its core design decisions—hardware memory safety, silicon-level garbage collection, and single-level persistent storage—have become the frontier of modern computer architecture.

Hardware-Level Object Orientation

The Rekursiv was designed to eliminate the "semantic gap" between high-level object-oriented languages and the underlying hardware. Unlike conventional CPUs, the Rekursiv treated memory and disk as a single persistent object store where programmers never saw a physical address.

Key Architectural Innovations

• Hardware Memory Safety: The OBJEKT chip translated 40-bit object identifiers into physical locations via a hashed pager table. It checked the type and bounds of every memory access in hardware, making it impossible to run off the end of an array or forge a reference.
• Silicon-Integrated Garbage Collection: Because the OBJEKT chip managed all physical locations, the hardware could relocate objects freely. The CPU featured a two-space compacting garbage collector built into the silicon that moved live objects in DRAM while execution continued uninterrupted.
• Recursive Microcode: The machine lacked a fixed instruction set; instead, it used a loadable instruction set. Microcoded instructions could be arbitrarily complex and even call themselves, allowing for the implementation of language-specific instructions (e.g., Prolog unification as a single instruction).
• Persistent Object Store: Memory and disk were treated as one. If a required object was not in DRAM, the processor would stall mid-instruction while an external disk processor fetched the object, then resume execution seamlessly.

Why the Rekursiv Failed: The Commodity Curve

Despite its technical ambition, the Rekursiv was crushed by the "attack of the killer micros"—the rapid rise of commodity microprocessors (such as the Intel 386 and SPARCstations) between 1986 and 2003, which improved at roughly 52% per year.

The RISC Revolution

By the time the Rekursiv emerged in 1988, the industry consensus had shifted toward RISC (Reduced Instruction Set Computer) architectures. Research from Berkeley's SOAR project demonstrated that simple instructions, combined with efficient caches and compilers, could outperform complex, hardware-heavy instruction sets. The Rekursiv's assumption—that hardware should rise to meet the language—was undercut by the reality that simple hardware running optimized software was faster and cheaper to produce.

Execution vs. Idea

While Linn claimed spectacular performance (e.g., a CONS cell every two microseconds), these figures were based on internal simulations and were not independently reproduced. Field comparisons suggested that general-purpose workstations, such as the Sun-3, could outperform the Rekursiv in running the LINGO language it was specifically designed for.

The Modern Resurgence of Rekursiv's Ideas

Forty years after the Rekursiv's demise, its four defining design decisions are now central to modern high-performance and secure computing:

1. Hardware Memory Safety (CHERI)

The Rekursiv's approach to unforgeable references and hardware-enforced bounds is mirrored in the CHERI (Capability Hardware Enhanced RISC Instructions) architecture. Developed at Cambridge and SRI, CHERI is now implemented in Arm's Morello prototype boards and the Memory Tagging Extension (MTE) found in modern Android phones. Microsoft research indicated that CHERI could have mitigated two-thirds of the memory-safety vulnerabilities patched in 2019.

2. Garbage Collection as Architecture

The concept of hardware-assisted memory management was explored by Azul Systems' Vega appliances, which used custom multicore processors with hardware read-barrier support to enable pause-free Java heap collection (the C4 collector).

3. Single-Level Persistent Stores

The ambition to merge memory and disk into a single store persists in IBM i (descended from the System/38) and was attempted by Intel with Optane (3D XPoint) before its wind-down in 2022. These ideas are currently migrating into CXL (Compute Express Link) memory fabrics.

4. Domain-Specific Architectures (DSAs)

The shift toward "workload-shaped silicon" is now the industry standard. Modern AI accelerators—such as Google's TPU, Groq's streaming processor, and Etched's transformer ASIC—are built to run specific computational languages (like linear algebra) efficiently, mirroring the Rekursiv's goal of building hardware for a specific language (Smalltalk/LINGO).

Lessons in Abstraction and Timing

The Rekursiv's failure highlights a critical distinction between welding semantics into silicon and placing them in a virtual instruction set.

• The Hardware Trap: Linn welded its semantics into four specific gate arrays. When the process node became obsolete, the machine died.
• The Abstraction Success: IBM's System/38 succeeded by using the Technology Independent Machine Interface (TIMI), a virtual instruction set that allowed the platform to migrate from one processor to another (e.g., to PowerPC in 1995) without requiring customers to recompile their applications.

As the commodity curve of general-purpose CPUs flattens, the industry is returning to the Rekursiv's philosophy: creating bespoke hardware tailored to specific workloads, provided the ideas are decoupled from the specific silicon process node.