Someone Ran Factorio Off Of 1,000 AOL Floppy Disks, And It Took Way Too Long

The Intersection of Retro Computing and Modern Gaming Obsession

In the vast landscape of technological challenges and engineering marvels, few projects capture the imagination quite like the audacious attempt to run a modern computational heavyweight on archaic hardware. We are talking about a feat that defies conventional logic and pushes the boundaries of what is considered possible. A recent project has captivated the technology community by attempting to run Factorio, a notoriously CPU-intensive factory simulation game, entirely off the storage medium of a bygone era: AOL floppy disks. Specifically, 1,000 of them. The premise is as absurd as it is fascinating, and the result was a lesson in patience that stretched into a temporal expanse most would consider “way too long.”

This undertaking was not merely a test of hardware but a testament to the sheer persistence of human curiosity. To the uninitiated, Factorio is a game that demands precision, optimization, and significant processing power to manage complex supply chains and sprawling factory layouts. The game engine calculates resource flows, pathfinding, and production rates in real-time. To subject this demanding software to the bottleneck of a 1990s storage solution—specifically, the 1.44 MB capacity of a standard high-density 3.5-inch floppy disk—creates a computational bottleneck of monumental proportions. This article delves into the technical intricacies, the hardware hurdles, and the sheer temporal cost of running a modern simulation on a stack of magnetic media that once served as the gateway to the internet for millions.

The Impossible Hardware Setup: Bridging the 1990s and the 2020s

To understand the magnitude of this project, one must first appreciate the technological chasm being bridged. We are looking at a scenario where the storage access times are measured in seconds rather than milliseconds, and bandwidth is measured in kilobytes per second, not gigabytes. The primary challenge in running Factorio from 1,000 AOL floppy disks is not just the storage capacity, but the physical interface and the operating system capable of addressing such a setup in a meaningful way.

The Legacy of AOL Disks

AOL (America Online) floppy disks are cultural artifacts. They represent the dawn of the consumer internet. However, they are functionally identical to standard MS-DOS formatted floppy disks, with one distinct difference: they are often “write-protected” or formatted to run specific installer software. For this project, the disks had to be reformatted to serve as a raw storage volume. The total capacity of 1,000 disks equates to approximately 1.44 Gigabytes (GB). For context, the base installation of Factorio (depending on the version) can range from 500 MB to over 1 GB, leaving very little room for the operating system or swap space.

The Bootloader Challenge

Running any software from floppy disks requires a robust bootstrapping process. We are not simply copying files; we are constructing a computing environment from scratch. The engineer behind this project likely utilized a custom bootloader. This bootloader must be small enough to fit on the first disk (often the “Insert Disk 1” scenario) and capable of recognizing subsequent disks in the sequence. The system likely utilized a stripped-down Linux kernel or a minimal DOS variant. The complexity arises when the game attempts to load assets that are not contiguous on a single drive but are scattered across hundreds of physical platters.

The Robotic Arm Necessity

With 1,000 disks, manual swapping is impossible. The “way too long” duration refers not just to loading times but to the physical act of disk manipulation. We suspect the use of a robotic floppy disk changer—likely a custom-built rig or a repurposed archival device. This mechanism acts as a physical stack, capable of ejecting a spent disk and inserting the next one in the sequence with mechanical precision. The latency introduced by the mechanical arm moving, aligning, and inserting a disk adds significant overhead to every single data read request the game makes.

The Software Engineering: Virtualizing the Floppy Array

The software side of this equation is perhaps even more complex than the hardware. Modern operating systems are not designed to treat a linear sequence of removable media as a single, persistent file system. The project required a sophisticated virtual block device driver.

The Linear Block Device Driver

To the operating system, the 1,000 disks must appear as a single hard drive partition (e.g., /dev/fd0 through /dev/fd999 or a virtual aggregation). The driver must keep track of the “current” disk and the “target” disk for every read operation. If Factorio requests a file located on Disk 742, the system must calculate the distance from the current disk and initiate the robotic change sequence. This results in a state where the system spends 99% of its time waiting for physical media transport and only 1% actually reading data.

Memory Paging and Swap Hell

Factorio is a memory-hungry application. In a standard environment, it utilizes RAM and fast SSDs for virtual memory (swap/paging). In this floppy-based environment, the “swap file” would be distributed across the disk array. This creates a scenario of “Thrashing,” a state where the system spends all its time moving data between storage medium and memory, performing no actual computation. Every time the game needs to calculate a recipe or move an item on a conveyor belt, it might trigger a page fault that requires swapping in a specific asset from Disk 512. The delay between the request and the data arrival would be measured in minutes, not seconds.

The Gameplay Experience: A Test of Human Endurance

We must address the reality of attempting to play Factorio under these constraints. The game is known for its “crack-like” addictiveness, derived from smooth feedback loops and rapid iteration. This project obliterates those loops.

The “Insert Disk” Prompt

The prompt “Insert disk 439 to continue” is not just a nostalgic quip; it is a functional reality. If the game engine tries to load a texture or sound file located on Disk 439, and the robotic arm has just read Disk 100, the user (or operator) must wait for the mechanical cycle to complete. We are looking at load times potentially stretching into the hours for a single action. Booting the game itself could take a full day. The game would likely be running at a frame rate measured in minutes per frame (mpf), rather than frames per second (fps).

Input Latency and Event Handling

The input lag would be unprecedented. When a player clicks a button to build a mining drill, that input signal must be processed by the CPU, which might be waiting on a disk read for the game logic to execute. The physical delay of the storage system creates a disconnect between action and reaction that makes the game practically unplayable in a traditional sense. However, the spectacle of watching the factory slowly build itself, disk by disk, becomes the actual “gameplay” experience. It transforms Factorio from a strategy game into a performance art piece about computational endurance.

Calculating the Temporal Cost: Why It Took Way Too Long

To quantify “way too long,” we must break down the I/O operations. Let us assume an average seek and swap time for the robotic arm of 10 seconds per disk change (a conservative estimate for mechanical robotics). Let us also assume the read speed of a floppy disk is roughly 125 KB/s.

The Load Time Calculation

If Factorio requires reading 800 MB of data to reach a playable state:

1. Data Volume: 800,000 KB.
2. Sequential Reads: Ideally, the data is perfectly distributed across disks. However, with fragmented data, you could be swapping disks thousands of times.
3. The Worst-Case Scenario: If every asset is on a different disk, you are looking at 800,000 / 1.44 ≈ 555,555 distinct files. Even if we only swap disks once for every 100 files (assuming 100 files per disk), we are looking at 5,555 swaps.
4. Time Calculation: 5,555 swaps × 10 seconds = 55,550 seconds ≈ 15.4 hours just for the mechanical movement.
5. Read Time: 800,000 KB / 125 KB/s = 6,400 seconds ≈ 1.7 hours.

Total boot time to a playable menu: Approximately 17 hours. This assumes perfect conditions. In reality, with overhead, debugging, and robotic calibration, this extends into days.

The “Save Game” Nightmare

Saving the game state is equally terrifying. Factorio saves the state of every entity on the map. A late-game factory produces a save file that can be tens or hundreds of megabytes. Writing this data back to 1,000 floppy disks involves the same mechanical process in reverse. A single save operation could take the better part of a day. This means that once the game is actually running, the player cannot stop, or they risk losing progress due to the sheer temporal cost of saving.

The Philosophical Implications of Retro-Tech Revival

Why would anyone undertake such a project? It is a question of pushing limits. In an age of cloud computing and instant SSD loads, the friction of vintage computing is a reminder of how far we have come.

Preserving the Legacy of AOL

Using AOL disks specifically adds a layer of irony. These disks were designed to connect users to the World Wide Web—a system designed for speed and connectivity. Using them to run a game that simulates industrial inefficiency is a poetic juxtaposition. It honors the physicality of data in an era that has largely become abstract.

The Value of “Hard Mode” Engineering

For the engineers and enthusiasts at communities like Magisk Modules, the challenge of optimizing software for constrained environments is a familiar concept. Whether it is tweaking a mobile operating system for maximum performance or, in this extreme case, forcing a modern game to run on 1990s hardware, the drive is the same: mastery over the machine. It proves that with enough ingenuity (and enough floppy disks), the software will eventually yield to the hardware.

The Technical Specifications of the 1,000 Disk Array

To fully appreciate the scale, we must look at the physical footprint. 1,000 disks, stacked or stored in a carousel, occupy a significant amount of volume. We are dealing with a physical storage system that weighs tens of kilograms.

Connectivity and Daisy Chaining

The computers of the era that used floppy disks (like the 386 or 486 PCs) rarely had the processing power to run the game logic of Factorio, even if the storage problem were solved. Therefore, the setup likely involved a modern single-board computer (like a Raspberry Pi or an industrial PC) acting as the interface controller, connected to a vintage floppy drive controller or a USB-based floppy drive emulator. The emulation of a 1.44 MB drive over a USB interface adds another layer of software abstraction that can introduce instability.

The Failure Rate

Mechanical components fail. Floppy disks are magnetic media that degrade over time. “Bit rot” is a real phenomenon where data becomes corrupted on the disk surface. In a project of this magnitude, the risk of a single bad sector on Disk 850 rendering the entire installation futile is high. The operator likely had to verify the integrity of every single disk before beginning the process—a process that itself could take days.

Conclusion: A Monument to Computational Patience

The attempt to run Factorio off 1,000 AOL floppy disks is a triumph of absurdity and engineering. It highlights the stark contrast between the exponential growth of computational speed and the physical limitations of storage media. While the game ran at speeds that could be described as geological, the fact that it ran at all is a marvel.

This project serves as a benchmark for extreme computing environments. It demonstrates that software is ultimately bound by the hardware it runs on, and that “impossible” is merely a challenge to be overcome with enough time and resources. For those of us fascinated by the modding community and the boundaries of system performance—areas we frequently explore at the Magisk Module Repository—this serves as a reminder that the creativity of the human mind knows no bounds, even if the patience required to watch a factory build one item every ten minutes certainly does.

The project stands as a hilarious, slow-motion replay of the evolution of technology, proving that while we can make games more complex, we should be thankful for the NVMe drives that keep them playable. The next time you complain about a game taking 30 seconds to load, remember the person waiting 30 hours for Disk 439 to finally arrive.