Web Archiving and the Historical Reality of OldWeb.Today

For decades, we have relied on digital time-travel portals like the Internet Archive’s Wayback Machine, operating under the comfortable assumption that we are looking at history exactly as it was. Yet, there is a fundamental flaw—a silent, convenient illusion—that underpins the contemporary landscape of web archiving. When you paste an old URL into a modern browser, pick a year from a calendar, and hit enter, what you see is often a modern lie. The raw HTML of the past is being parsed, sanitized, and forced into compliance by a highly sophisticated, contemporary rendering engine. In doing so, we commit a form of digital revisionism, stripping historical web artifacts of their original visual mechanics, layout quirks, and interactive soul.

Enter OldWeb.Today, an open-source web archaeology platform spearheaded by Ilya Kreymer and the Webrecorder project. It challenges this “historical cheat” by introducing a radically different premise: to truly preserve the history of a webpage, you must also preserve the vintage operating system and software environment that originally compiled and interpreted it. Rather than simply translating obsolete code for a modern Chrome or Firefox tab, OldWeb.Today virtualizes entire legacy computers and classic browsers inside the modern browser, offering a pristine, unaltered window into the web as it was actually lived.

The “Historical Cheat” of Modern Browser Repositories

To understand why platforms like OldWeb.Today are necessary, one must first dismantle how standard web archiving replay systems function. Conventional platforms retrieve historical files (typically stored in WARC or ARC formats) and serve them directly to your modern browser. However, modern browsers are not neutral conduits; they are active interpreters. They constantly make silent, real-time decisions about security protocols, layout algorithms, script execution, and typography. When a modern browser encounters code written in the 1990s or early 2000s, several things break:

• Layout Engines: Modern layout engines like Blink (Chrome) or Gecko (Firefox) have completely abandoned support for obsolete design standards, such as nested table layouts, absolute frame positioning, and proprietary HTML tags like <marquee> and <blink>.
• Security and Encryption: Contemporary browsers enforce modern security models (such as modern TLS standards and strict CORS policies). Legacy scripts, cross-origin requests, or unencrypted HTTP elements are blocked or modified. This means interactive components of old sites often fail silently.
• System Fonts: Many classic sites relied on system-specific fonts (like MS Sans Serif or early TrueType fonts) that are no longer pre-installed on modern operating systems, resulting in fallback rendering that distorts the original design aesthetic.
• Dynamic Code Execution: Obsolete scripts, early forms of JavaScript, and deprecated APIs are frequently ignored by modern engines, leaving once-interactive portals flat and unresponsive.

The result is a sanitized, often broken approximation of the original artifact. It is the digital equivalent of taking an oil painting from the Renaissance, scraping the paint off the canvas, and repainting it with modern acrylics to fit a contemporary frame. The data is technically there, but the authenticity is lost.

Under the Hood: The Complex Stack Behind the Web’s Time Machine

OldWeb.Today avoids this rewriting of history by leveraging a complex, client-side stack of JavaScript and WebAssembly (Wasm) emulators. When a user selects a classic browser on the platform, they are not loading a theme; they are booting up an entire, isolated virtual machine. This architecture is powered by several interconnected open-source technologies:

1. Virtualizing the Iron: v86 and Basilisk II

To run different operating systems, OldWeb.Today relies on two primary emulation engines compiled to run directly in the client’s browser:

• v86 (JavaScript x86 Emulator): Developed by Fabian, this remarkable emulator runs fully functional x86-compatible operating systems. OldWeb.Today uses v86 to spin up vintage Windows (such as Windows 98) and early Linux distributions, allowing users to interact with the original operating system UI alongside the browser.
• Basilisk II (JS Port): To preserve the classic Macintosh experience, the platform utilizes a JavaScript port of Basilisk II (originally ported by James Friend). This virtualizes 680×0-based Macintosh environments, specifically targeting Mac OS System 7, and enables the execution of early Apple internet applications.

2. The Network Translation Magic

Running an operating system in an isolated sandbox within a modern browser tab creates an immediate technical hurdle: how does a virtualized, 25-year-old operating system connect to the internet? It has no direct access to your physical network interface card. To solve this, developers modified the emulators to hook into an ingenious in-browser network stack developed by the bwFLA Emulation as a Service (EaaS) team:

• picotcp.js: A WebAssembly build of picotcp—a highly modular, lightweight TCP/IP stack designed for embedded systems. This acts as the virtual router, handling the ethernet and TCP/IP layers entirely within JavaScript.
• webnetwork.js: This application layer translates the emulated browser’s network requests into a format the host browser can handle. It terminates HTTP and HTTPS connections originating from the guest OS and reroutes them.
• CORS Proxy Integration: Because modern security standards enforce strict Cross-Origin Resource Sharing (CORS) rules, the guest browser cannot query external archives directly. OldWeb.Today routes these requests through a remote CORS proxy.
• CDX Server Queries: The platform translates standard URL requests into queries directed at massive digital repositories, primarily the Internet Archive’s Wayback CDX Server API, or local deployments of pywb (Python Web Archive). It retrieves the exact archived file (utilizing the id_ modifier, which serves raw, unmodified content without the Wayback Machine’s injected modern banner) and injects it back down the virtual network pipe into the emulated browser.

The Retro Software Library: Restoring Obsolescence

Through this virtualized infrastructure, OldWeb.Today grants users access to an extraordinary catalog of internet history. This is not just a visual museum; it is an active laboratory where researchers can experience the Web exactly as it was experienced by users in different technological eras. The platform includes legendary and obscure browsers, such as:

1. NCSA Mosaic: The browser that popularized the World Wide Web in 1993, allowing graphics to be displayed inline with text rather than in separate windows.
2. Netscape Navigator (v3 and v4): The commercial powerhouse of the mid-to-late 1990s, complete with early, erratic rendering of tables and frames.
3. Internet Explorer (v4, v5, and v6): The dominant, proprietary giant that defined the “browser wars” and introduced many of the non-standard behaviors that web developers spent decades trying to bypass.
4. Early Builds of Opera, Safari, and Firefox: Showing the gradual transition toward modern web standards and tabbed browsing.

Crucially, these environments do not exist in isolation. They are pre-configured with the exact software dependencies required to render active components of the early web. Netscape and IE instances are equipped with authentic installations of Java 1.0/1.1 and early versions of Shockwave/Flash (such as Flash 9 on Windows 98 or Shockwave 4 on Macintosh). This means that raw Java applets and complex Flash animations—which have been completely purged from the modern web due to security vulnerabilities—load, compile, and execute with absolute high-fidelity accuracy.

For scenarios where running a full, heavy virtual machine is inefficient, OldWeb.Today also integrates Ruffle, a modern, open-source Flash player emulator written in Rust and compiled to WebAssembly. This allows users to view Flash content in their native modern browsers at high speed, without the overhead of operating system emulation, demonstrating the platform’s pragmatic, multi-tiered approach to digital preservation.

The Paradigm Shift: Why Emulation Restores the Integrity of Web Archiving

By forcing us to experience the load times, the rendering errors, and the system dependencies of the past, OldWeb.Today changes our relationship with digital history. It strips away the slick, instantaneous optimization of the modern web and reintroduces us to the material realities of the past. Navigating a website from 1997 on an emulated dial-up connection using Netscape Navigator 3.0 is a sensory experience. You are forced to wait as progressive JPEGs slowly resolve line-by-line. You experience the erratic layout reflows as the browser calculates nested table heights. You encounter the actual browser-exclusive design choices that divided the web into “Best Viewed in Internet Explorer” or “Best Viewed in Netscape.”

This approach highlights a growing consensus within contemporary digital preservation and digital humanities: the history of the web is not merely a database of raw data, files, and text. It is an intricate, highly specific ecosystem of hardware, operating systems, and software environments that gave that data its form, aesthetic, and meaning. When we view old data through a modern lens, we lose the context of its creation. We lose the boundaries, the limitations, and the creative solutions that early designers utilized to work within those constraints.

OldWeb.Today acts as a vital correction to the historical record. By prioritizing emulation over modernization, it protects the beautiful imperfections of the early web, ensuring that future generations of digital historians can study the digital landscape not as a flat, modern reconstruction, but as a living, breathing, and delightfully quirky historical reality.