An open-source technology stack to preserve today's software in runnable form for 1,000 years.
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 100 years from now
Why Emulation Isn't The Solution
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.
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 now on GitHub), anyone can build capsules from their own software.
A reference virtual machine to run capsules is written in C and is less than a page of code. The complete specification is short enough to fit on a napkin, so that someone in the future can build a working VM from scratch 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.
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.
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.
Virtual Machine
~50 Lines of Code
The entire Eternal Computer virtual machine, capable of running Linux and all preserved software, fits in around 50 lines of 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.
To Whoever Finds This
If you've discovered a capsule and the napkin and are reading this years, decades, or centuries from now - you have everything you need. Follow the instructions on the napkin to build a virtual machine, and the software inside the capsule will come back to life.
No other materials are required.
Eternal Software Initiative · 2026 CE