Archival-quality future-proof pseudo-CPU architecture

Question

Suppose we maintain a massive electronic library of texts/photos/videos etc., and want to ensure that these files are readable indefinitely long in the future. [Update] one of the major problems with digital libraries is the program rot: due to bugs in content creation and/or content playback software (and due to feature removal from playback software):

Many documents can be reproduced only on particular versions of software, of the OS and of the computer hardware.

So we:

• Keep snapshots of versions of OS/software which are known to read these files without errors.
• Keep snapshots of VM implementations which are known to run these OS/software versions without errors.

However, this is obviously not enough: for the best result, we need to preserve the versions of CPU on which the VM implementation is running!

The only exit of this vicious circle seems to have “a virtual CPU”: a “virtual instruction set” which is:

• Powerful enough so that one can recompile the VM mentioned above to run on this pseudo-CPU.
• Simple enough so that one can write a very simple interpreter for this instruction set (e.g., in a pseudo-code — but it better be compilable for periodic checks of it working!).

The target is that N (or N²) years in the future, a future librarian should be able to quickly rewrite this “sample interpreter” into whatever programming language is available at that time. After this, the library becomes readable. (In other words, all one should provide is:

• A general human-readable instruction how to navigate the library;
• The human-readable (pseudo-)code of the interpreter.
• A blob keeping the compiled VM, the OS and the reader programs.
• A blob keeping the library.)

Of course, in the best of the worlds, such a CPU architecture would be already available!

Question: is it available? If not, how close it is to being available?

Answer 1

The problem is that you're replacing a relatively simple problem with a harder one.

We already have a number of well documented file formats. These cover documents, still images, sounds and video. They have been implemented on multiple operating systems on multiple hardware platforms. So we know that the standards are well enough written.

You want to replace that with a whole VM running on a virtual CPU. But you still have to document how to implement the thing so well that someone decades in the future can implement it on whatever machine they have. And if they do get the content to display or play, it's now embedded in an entire VM, making it harder to paste it into another document.

Also, when video standards are first drawn up, they require special hardware or the fastest processors to implement them. Once you add the overhead of running a VM, they become impossible to implement on any hardware we have. Much better to describe the process of decoding the format, and letting people implement in the most efficient way on their platform.

Answer 2

This is absolutely possible. You can just pick literally any general-purpose CPU architecture that's simple enough for your liking - for example, a Z80 with a memory-banking extension - and write an interpreter for other architectures on that one.

Z80 is relatively simple (and you could even remove the less-than-simple parts). x86_64 is not. If you have a x86_64 interpreter written for Z80, you only have to write new Z80 interpreters as technology advances.

It will be slow, of course, but fully functional. Interpreted emulation is always slow, and you are proposing to use two layers of it. One or both can be a JIT compiler, but then you are adding a huge amount of complexity which could break down in unexpected ways. Future generations can always write their own JIT using your interpreter as a reference.

---

By the way, human languages evolve. The year is 4040 and English has the status that ancient Egyptian hieroglyphs do today. Can they read your instruction set description? You may need to bootstrap your description from scratch - like we tried to do with the Voyager records. Luckily mathematics is universal and timeless, so you can assume they'll have the concepts available, but not the notation. You have to design a record they can look at and think "hey, wait a minute! That's binary addition!" Think something like:

- | |- || |-- |-| ||- ||| |--- |--| |-|- |-|| ||-- ||-| |||- ||||

|- || |-| ||| |-|| ||-| |---| |--|| |-||| |||-| ||||| |--|-|
# optionally add more prime numbers until you run out of carvings
# maybe write e and pi and sqrt(2) in binary to introduce the "decimal" point symbol

-   +   -   =   -
|   +   -   =   |
-   +   |   =   |
|   +   |   =   |-
||--|   +   |--|-   =   |-|-||
(include a bunch more binary addition examples here)

(same for subtraction)
(and it just goes on and on like this)