The Internet Archive

A library that decided software counted

When Brewster Kahle founded the Internet Archive in San Francisco in 1996, the explicit ambition was to build a library for the digital age — one that would do for the web what national libraries had done for print: collect everything, keep it, and make it available. The Wayback Machine, launched publicly in 2001, became the most visible expression of that mission, archiving crawled snapshots of web pages at scale. But the Archive's remit quietly expanded beyond HTML and images. Software was also a document of its time, and the Archive began treating it as one.

The software library grew in stages. Physical media — floppy discs, CD-ROMs, cartridges — was digitized and catalogued. Console ROMs arrived alongside DOS games and early Macintosh software, each item given a metadata record and a permanent URL. The Internet Archive's software collection now runs to millions of items, spanning decades of personal computing history. What made this more than a file dump was the Archive's early decision to pair preservation with access: a stored file that nobody could run was only half the job done.

That decision had a technical consequence. Static files — disc images, binary executables — are inert without the environment that once ran them. A floppy image from 1984 needs an operating system, a CPU architecture, and usually a monitor that no longer exists. The Archive's answer was in-browser emulation: run the old environment inside the page, so the visitor never needs to install anything. The framework built to do this is the Emularity, developed in collaboration with the archive community, and it pipes emulators compiled to WebAssembly directly into the browser. The visitor clicks play; the emulator boots; the software runs as it did on the original hardware. The join is nearly invisible.

The Flash problem and the browser-based fix

Flash presented a distinct challenge. Unlike DOS software, Flash games had not been abandoned for decades before anyone noticed — they went from ubiquitous to unplayable inside a single month, when Adobe ended support and the browsers followed through with hard blocks in early 2021. The Archive already held thousands of Flash files, uploaded by users over the years. Overnight they became inert. The SWF files were intact; the runtime that could execute them was gone from every modern browser.

The Archive's response was to integrate Ruffle, the open-source Flash emulator written in Rust and compiled to WebAssembly. Ruffle is not a full reimplementation — ActionScript 3, the more complex scripting layer, is only partially supported — but ActionScript 2 and the earlier timeline-based content works well enough that a large proportion of the Archive's Flash catalogue plays in the page without any additional installation. The integration is transparent: a visitor landing on a Flash item in the Archive sees the familiar play interface, and Ruffle loads silently behind it. The emulator, not the game, is what runs in the browser. This is the key distinction in software preservation: emulating the runtime preserves whole classes of content at once, rather than requiring individual game-by-game ports.

The Archive also hosts and points to Flashpoint, BlueMaxima's large-scale offline preservation project, which approached the problem differently — capturing not just the files but the network environment those files expected. Games that phoned home for assets, licence checks, or multiplayer servers could not be preserved by file-capture alone; Flashpoint's approach of archiving the server-side responses alongside the client closed that gap for a significant portion of the catalogue. The two projects are complementary rather than competing: the Archive provides open catalogued access; Flashpoint provides environmental depth.

Texts, text adventures, and the longer thread

Before any of this, the browser itself was a text platform, and the Archive holds that history too. Will Crowther's original 1975–76 source code for the game that became Colossal Cave Adventure survived on a backup tape recovered decades later; scanned documents, early network maps, and ARPANET-era materials in the Archive's collections trace the infrastructure that made networked play possible at all. The lineage from those text environments to the first multi-user systems is part of what the Archive holds as document rather than playable software — and the two categories, text record and executable artefact, sit alongside each other in the same catalogue.

The MUD tradition itself — the persistent shared worlds that Roy Trubshaw and Richard Bartle developed at the University of Essex from 1978 onward — is represented in the Archive less as runnable code than as a documentary record: period manuals, academic papers, Bartle's own writing on game design and player taxonomy. The social and design history of these systems is preserved in text even where the running environments are not. That combination of the executable and the contextual document is part of what distinguishes an archive from a file host.

What the Archive is not, and what that means

The Internet Archive is not a curated preservation project in the way that institutional archives are. Items arrive through upload, crawl, and donation; metadata quality is uneven; duplicates accumulate. The Software Preservation Network, a consortium of research libraries, works on the more rigorous end of the problem — provenance, format documentation, legal frameworks for access — and the Archive interoperates with those efforts without replicating them. The Computer History Museum and the Video Game History Foundation focus on acquisition and documentation at a depth the Archive does not attempt for every item.

What the Archive offers instead is scale and accessibility: an open catalogue with stable URLs, searchable metadata, and in-browser play for a growing portion of the holdings. The Wayback Machine means that the web pages that once hosted browser games — the portals, the developer sites, the sponsor pages behind the preloaders — are often recoverable even when the games themselves require more work. The context survives alongside the content.

The Wayback Machine, launched publicly in 2001, became the most visible expression of that mission, archiving crawled snapshots of web pages at scale.

The practical consequence for anyone trying to understand what browser games were — what platform they ran on, who made them, how they circulated — is that the Archive is where most of the accessible evidence sits. Not all of it is playable; not all of it is complete; not all of the metadata is reliable. But it is open, it is large, and it has been there long enough that it has become part of the infrastructure of digital memory in a way that no private platform has managed. A library that decided software counted turned out to matter.