When people talk about preserving software, they usually mean keeping archives, source code mirrors, emulator images, or old binaries running through lots of compatibility fixes. Eternal takes a different approach. It asks what would happen if computers were made so simple that someone in the distant future could rebuild one from a short description and run today’s software again.
This is the main idea behind the Eternal Software Initiative, an open-source project that aims to keep software runnable for… 1,000 years. At its core is the “Eternal Computer,” a purposely simple virtual machine built around just one instruction.
The single instruction is called Subleq, which stands for “subtract and branch if less than or equal to zero.” Basically, the machine subtracts one number from another and then decides what to do next based on whether the result is zero or negative. No more, no less. That’s the entire foundation.
I know that at first this might sound like just a computer science experiment, not something that could actually run Linux. But Eternal does just that. The project uses a modified version of Subleq called Subleq+, along with an LLVM backend, a Linux kernel port, C and C++ runtime support, uClibc-ng, BusyBox, and a reference virtual machine. The end result is a self-contained Linux capsule that can boot to a shell inside this tiny machine.
The project argues that modern software is tough to preserve because it relies on so many other things. A program needs an operating system, libraries, compilers, frameworks, hardware behavior, firmware, file formats, and lots of assumptions from its own time. Saving just the binary often isn’t enough. Even if you save an emulator, that emulator becomes another complicated thing future systems have to figure out.
Eternal tries to make this problem simpler. Instead of expecting people in the future to rebuild today’s hardware and software, it defines a machine so basic that its design can be written down in a tiny format. According to the project site, the reference virtual machine is about 30 lines of pseudocode, and the GitHub README says the C version is around 50 lines.
Eternal packages preserved software into what it calls capsules. Each capsule includes the operating system, libraries, applications, and all dependencies in one bundle. In the project’s example, this means a Linux-based capsule that the Eternal VM can load and run again.
This is where the project gets interesting in a fun way. The GitHub repository has instructions for building the VM, unpacking a Linux boot image, running it, and launching software inside. The README even suggests trying DOOM once Linux is up and running.
Eternal isn’t meant to be a practical Linux distribution, and it doesn’t try to be. It’s not a replacement for QEMU, a new desktop platform, or a realistic way to run everyday software. Its real value is in the question it raises: how simple would a computer need to be for software preservation to last for centuries, not just decades?
But the Linux part is real. It covers the whole software stack: LLVM for compiling, Linux as the operating system, BusyBox for user tools, runtime libraries, and a VM to run the capsule. It’s a rare experiment where something extremely minimal and very practical comes together in one place.
There’s a bit of historical irony here. Linux usually runs on more and more complex hardware, like servers, laptops, phones, embedded boards, and cloud systems. Eternal does the opposite. It reduces the machine to a nearly primitive model, then adds just enough tools to make Linux run on it anyway.
It’s still unclear if Eternal will turn into more than just an interesting experiment. The project is new, and its goals are ambitious. No one can say for sure if a software capsule will still work 1,000 years from now. But as an open-source curiosity, it’s hard not to appreciate the idea.
So, could someone far in the future still start up a piece of our digital world if all they had was a capsule, a short machine description, and the ability to subtract numbers? For a project based on just one instruction, that’s a surprisingly big idea.
Those interested can learn more on the project’s GitHub repository.
