Bringing Early Linux Kernels to the Browser: Building Linux Time Machine

Exploring Linux history through x86 emulation, historical kernels, WebAssembly, and interactive browser environments.

Why I Built Linux Time Machine

I’ve been working with Linux professionally for more than 15 years. During that time, I’ve watched the ecosystem evolve through major changes in system administration, virtualization, containers, cloud infrastructure, and kernel development.

But I’ve always been fascinated by where it all began.

What did Linux actually look like in 1991? How different was an early Slackware installation from a modern Linux distribution? And could those environments be made accessible directly in a modern browser?

These questions inspired me to build Linux Time Machine, an open-source project that lets visitors explore the evolution of Linux from its earliest releases to today.

The project is available here:

Live website: https://linuxtimemachine.org/

Source code: https://github.com/hamdyaea/linux-time-machine

My goal wasn’t simply to create a timeline containing screenshots and historical descriptions. I wanted visitors to interact with Linux history, using historical x86 guest environments where possible and educational recreations for later milestones.

That distinction is important because a simulated terminal is not the same as a running historical Linux kernel.

  1. Linux 0.01: Going Back to 1991

Linux 0.01 was released by Linus Torvalds in September 1991.

It was an experimental kernel targeting Intel 386 hardware, not a complete Linux distribution with the features we expect today.

It existed in a very different technical environment:

  • Early 32-bit x86 hardware.
  • Limited memory and disk resources.
  • A MINIX-compatible filesystem.
  • No modern Linux desktop.
  • An early system-call interface and process scheduler.
  • Toolchains and boot assumptions very different from those used today.

One of the first challenges was finding a reproducible way to build and execute a Linux 0.01-derived kernel using modern development tools.

For the experimental build workflow, I used the compatibility-patched Linux 0.01 project maintained at:

https://github.com/joeangel/linux-0.01

The first stage involves building the historical kernel and checking its behavior in QEMU.

However, successfully booting a kernel in QEMU doesn’t automatically mean it will work in a browser-based emulator.

That leads to the next challenge.

  1. Running x86 Linux Inside a Browser

For browser emulation, Linux Time Machine uses v86:

https://github.com/copy/v86

v86 is an open-source x86 emulator designed to run PC software inside a web browser, with WebAssembly support.

Instead of requiring users to install a traditional virtualization application, the browser loads the emulator and its virtual machine resources.

The relevant components include:

  • The v86 JavaScript runtime.
  • The v86 WebAssembly binary.
  • SeaBIOS and VGA BIOS.
  • Historical boot media.
  • Virtual hard-disk images.
  • Browser code that configures and controls the virtual machine.

A simplified view of the architecture looks like this:

Browser interface → v86 emulator → emulated x86 hardware → historical boot media → Linux kernel and userspace

The historical operating system runs within the emulated environment. The browser supplies the display, keyboard interaction and other supporting functionality.

This is fundamentally different from rendering a command prompt with JavaScript.

The boot problem

Early Linux kernels weren’t designed around all the conventions used by modern bootloaders.

For example, the Linux 0.01 Image produced by the compatibility build is not automatically a modern Linux boot-protocol bzImage.

The browser configuration therefore needs appropriate boot media and a compatible disk layout.

In my 1991 configuration, the project uses a boot floppy, an IDE root disk and an additional placeholder IDE master device. That placeholder is needed by the emulator configuration to expose the historical disk on the expected IDE channel.

This is the type of detail that makes historical emulation more involved than simply loading a disk image into a virtual machine.

  1. Moving Forward to Slackware and Red Hat

Linux changed considerably during the 1990s.

By 1993, distributions such as Slackware were assembling the Linux kernel, user-space utilities and installation tools into usable systems.

Linux Time Machine includes browser guest configurations for several historical milestones:

Era Environment Guest memory configuration
1991 Compatibility-patched Linux 0.01 8 MiB
1993 Linux 0.99.12 / Slackware 1.01 16 MiB
1998 Red Hat 5.2 64 MiB
2004 Ubuntu-era environment 128 MiB

The 1991 and 1993 configurations use compatibility-modified historical kernels. The 1998 configuration uses a historical Red Hat disk image.

The 2004 environment is an Ubuntu-era recreation and should not be confused with an unchanged original Ubuntu 4.10 installation.

Each period introduces different considerations involving boot devices, storage, memory, display and operating-system compatibility.

My objective is to preserve the technical character of these environments while making them easier to explore.

  1. A Practical Problem: Hosting Historical Disk Images

One of the more interesting engineering challenges had nothing to do with rendering the interface.

It was the size of the disk images.

The website is hosted using Cloudflare Pages, which imposes a size limit on individual static assets.

Some historical disk images exceed that limit.

Instead of removing the disk images or replacing them with simulated terminals, I developed a packaging process that prepares the virtual disks for browser delivery.

For selected historical guests, the process works as follows:

  1. Prepare the historical disk using QEMU tooling.
  2. Convert the virtual disk to a raw image where required.
  3. Compress the image using gzip.
  4. Split the compressed image into smaller static files.
  5. Publish the parts alongside the emulator.
  6. Download and reassemble the compressed stream in the browser.
  7. Decompress the image using the browser’s DecompressionStream API.
  8. Provide the resulting virtual disk to v86.

In the packaging scripts, compressed images are split into 20 MiB parts to stay below the static hosting limit.

The browser also performs basic checks on downloaded resources. For example, it verifies that an expected emulator asset hasn’t accidentally been replaced by an HTML error page.

For the larger 2004 environment, the implementation instead uses a remote virtual disk endpoint designed for asynchronous disk access.

This avoids packaging the entire disk into the Cloudflare Pages static deployment.

These storage decisions are not very visible to visitors, but they are important for making the experience work.

  1. Historical Emulation Versus Educational Reconstruction

I wanted to avoid a common problem with retro-computing demonstrations: presenting a modern simulation as if it were an original historical operating system.

Linux Time Machine therefore combines two different approaches.

Historical x86 environments

For selected early milestones, the project configures v86 to execute historical guest environments using boot media and disk images.

The repository contains the browser integration, while the larger guest binaries and disks are packaged separately for deployment.

Educational recreations

For later milestones, the project offers interactive terminal and desktop recreations illustrating changes in Linux history.

These are browser-based educational interfaces, not original historical operating systems executing their original kernels.

A displayed kernel version or a simulated uname response does not prove that a genuine kernel is running.

For me, keeping that distinction clear is part of respecting the technical history of Linux.

  1. Building the Interface Without a Heavy Framework

The web interface uses a relatively straightforward stack:

  • HTML5.
  • CSS3.
  • Vanilla JavaScript.
  • WebAssembly through v86.
  • Cloudflare Pages for hosting.

The interface includes an interactive timeline, a terminal, historical explanations and a retro-futuristic time-machine design.

Visitors can select an era and explore how the Linux ecosystem changed over the decades.

On mobile devices, where running a complete historical x86 guest may not be practical, the project provides an interactive command experience instead.

This lets users explore the history without requiring an emulator to execute on every device.

The project is designed to be accessible without installing software locally.

  1. What I Learned

Working on Linux Time Machine has highlighted several important lessons.

Old software exposes assumptions we rarely think about today.

Boot protocols, disk geometry, hardware interfaces and kernel expectations have changed significantly over the decades.

Emulation doesn’t eliminate compatibility problems.

Even when an emulator reproduces x86 hardware, the kernel and its userspace must still work with the emulated devices and boot configuration.

Hosting is part of systems engineering.

File-size limits, compression, disk streaming and memory usage can determine whether a browser-based virtual machine is practical.

Historical accuracy matters.

Compatibility patches can be necessary, but those changes should be documented. Educational recreations should be identified rather than presented as original systems.

And perhaps most importantly, making old technology interactive can be a useful way to teach how modern systems evolved.

  1. Open Source and Future Development

Linux Time Machine is available as an open-source project under the MIT license. Historical third-party software, disk images and emulator components retain their respective licenses.

The public GitHub repository contains the website source, emulator integration and technical documentation.

Large historical disk images and emulator binaries are packaged separately, so cloning the repository alone does not reproduce every deployed virtual machine.

Some areas I’d like to continue improving include:

  • Compatibility with additional early Linux releases.
  • More reproducible historical kernel boot environments.
  • Better integration between the timeline and the emulator.
  • Additional historical distributions.
  • Improved educational explanations of kernel evolution.
  • Testing and documentation across different browsers.

I would especially welcome feedback from people interested in kernel development, old Linux distributions, x86 emulation and retro-computing.

Try Linux Time Machine

If you’re interested in exploring Linux history, you can try the project directly:

Website: https://linuxtimemachine.org/

GitHub: https://github.com/hamdyaea/linux-time-machine

Project video: https://youtu.be/GdhBmuVOcXc

Technical boot documentation: https://github.com/hamdyaea/linux-time-machine/blob/main/docs/REAL_KERNEL_BOOT.md

If you have experience with early Linux kernels or historical distributions, I’d be interested to hear your thoughts.

Which Linux release or distribution would you like to revisit in a modern browser?

⸻

About the author: Hamdy Abou El Anein is a senior Linux systems engineer and open-source developer based in Switzerland, with more than 15 years of professional experience working with Linux systems.