Eternal Software Initiative - Preserving Software for a Thousand Years

The Problem

Software Doesn't Last

So much of today's culture - art, science, story, work and play - is represented by or accessed through software. But software is inherently ephemeral.

Cultures of the past can be reconstructed from individual physical artifacts like objects and books, but software depends on a vast ecosystem - operating systems, compilers, frameworks, hardware - that must also be preserved. This ecosystem is complex and fragile, decaying over time, and much of it is proprietary and incompletely documented. Reconstructing the ecosystem in fully functional form in the far future may be impossible.

Without an active effort to preserve our software in usable form, today's culture will largely be invisible to far-future generations.

Clay tablet lifespan 5,000+ years and still readable today

Software half-life ~10 years before dependencies become obsolete

Without active preservation Zero chance of running today's software in 100 years

Why Emulation Doesn't Work

One approach is to translate hardware into a software emulator. Projects like QEMU do this for contemporary hardware. However, these emulators are necessarily almost as complex as the hardware they simulate: millions of lines of code, dependent on specific programming languages, libraries, and operating systems. Emulators can preserve hardware for decades, but not centuries.

You can't preserve the complex by wrapping it in more complexity. You have to simplify.

The Solution

The Eternal Computer

We started from the simplest possible target: a computer architecture with one instruction - so minimal that someone a thousand years from now could reimplement it without any specialized knowledge of our era's technology.

Then we built a production-grade LLVM compiler backend that compiles standard C and C++ programs directly for this target, with no source modifications required. We ported Linux to run natively on the architecture, giving preserved software the full infrastructure it expects: process management, file systems, preemptive multitasking.

Software, OS, and all dependencies get packaged into a single self-contained capsule - a sequence of numbers that encodes an entire software stack. We provide example capsules; with our open-source toolchain (available soon on GitHub), anyone can build capsules from their own software.

A reference virtual machine to run capsules is written in C and fits in around 20 lines of code. A complete specification - short enough to fit on a napkin - is provided so that someone in the future can build a working VM in under an hour and revive the software inside a capsule.

Architecture

Subleq+

One instruction: SUbtract and Branch if Less than or EQual to zero.

The entire instruction set is: subleq a, b, c — subtract mem[a] from mem[b]; if the result is ≤ 0, jump to c. That's it.

The + in Subleq+ adds indirect addressing — pointer support that enables re-entrant code. This is what makes it possible to run a full modern operating system with preemptive multitasking, without resorting to self-modifying code.

Despite having only one instruction, Subleq+ can represent any computation: from bitwise operations to full floating-point arithmetic. Implementing the virtual machine requires no knowledge of any specific programming language, OS, or hardware — only the ability to store numbers, subtract, and compare.

The One Instruction

mem[b] = mem[b] - mem[a]
if mem[b] ≤ 0 then
    pc ← c

With I/O: b = -1 outputs a character · a = -1 reads input

Capsules

Preserved Software

A capsule is a sequence of numbers that encodes an entire software stack - OS, libraries, applications - into a single self-contained artifact. Run on any Eternal Computer VM, today or millennia from now.

Eternal Linux

A complete Linux operating system port with C/C++ runtimes, booting to a shell on the Eternal Computer.

vmlinux.bootimage

The numbers in a capsule can be stored in physical form on a durable medium - for example, etched onto a titanium cylinder or inscribed in glass - which will last for millennia without degradation.

The VM

~20 Lines of Code

The entire Eternal Computer virtual machine, capable of running Linux and all preserved software, fits in around 20 lines of source code - simple enough to write on a napkin. A reference C implementation is available on GitHub, in two versions: text-only console output and framebuffer graphics.

Eternal Computer — Complete Pseudocode

function run_eternal_computer(capsule):
    mem ← 402,653,184 number slots, all 0
    pc ← 0
    timer ← 0

    — Load capsule: read numbers into mem —
    for i from 0 to length(capsule) - 1:
        element i of mem ← element i of capsule

    — Fetch one operand —
    function fetch:
        operand ← element pc of mem
        pc ← pc + 1
        if operand is odd:  return element (operand - 1) ÷ 4 of mem   — indirect
        otherwise:          return operand ÷ 4                        — direct

    — Main execution loop —
    loop:
        a ← fetch;  b ← fetch;  c ← fetch;
        if b is -1:  display ← element a of mem                       — output
        otherwise, if a is -1:  element b of mem ← keystroke          — input
        otherwise:
            element b of mem ← (element b of mem) - (element a of mem)
            if element b of mem is 0 or negative:  set pc to c        — branch
            if element 0 of mem is not 0 and timer is 1,000,000:
                element 1 of mem ← pc × 4
                pc ← (element 0 of mem) ÷ 4
                timer ← 0
            otherwise:     timer ← timer + 1
    until c is 0

To Whoever Finds This

If you've discovered a capsule and are reading this years, decades, or centuries from now — you have everything you need. The pseudocode above is a complete specification. Build a machine that can subtract and compare numbers, load the capsule, and run it. The software inside will come back to life.

No other materials are required.

Eternal Software Initiative · 2026 CE

Contact Us

Interested in the Eternal Software Initiative? Get in touch.