Somewhere near Düsseldorf, a 30-year-old copy of Windows 95 quietly goes about its daily business, processing 60,000 eggs without a single security patch since 2001. It’s not a museum piece or a retro-tech experiment—it’s the brains behind a 40-by-40-metre egg-sorting machine that farmer Peter Huber says runs “more smoothly than newer programs.” This quirky tale of industrial longevity, first reported by German broadcaster WDR and later picked up by PC Gamer, is more than a nostalgic chuckle. It’s a case study in why legacy systems persist, the real risks they carry, and what organizations can do before their own critical infrastructure becomes tomorrow’s tech relic.
The setup: vintage code in a modern food chain
Huber’s arrangement would send shivers down the spine of any IT security professional. A custom-built application, crafted decades ago by a developer who can no longer be reached, drives the entire operation. The software records egg counts, generates compliance labels, and interfaces with a faithful old Brother printer—a device whose own driver support likely evaporated long before Windows XP hit end-of-life. The sorting machine itself is mechanical; the PC logs results and handles reporting. Without it, traceability breaks, labels stop printing, and the farm’s output grinds to a halt.
Why hasn’t Huber upgraded? “Replacing the sorter would cost as much as buying a house,” he told WDR. With the original developer unavailable, rewriting the application for a modern OS would require reverse-engineering bespoke hardware interfaces and file formats—a risky, expensive endeavor. So Windows 95 hums along, rebooted occasionally, and delivers the goods. As long as the printer doesn’t die and the hard drive keeps spinning, the status quo feels like a bargain.
Why Windows 95 still runs in industrial niches
This egg farm isn’t an outlier. Across manufacturing floors, point-of-sale terminals, and laboratory equipment, Windows 95—and its era-mates—hold on because they’re entangled with three sticky forces: locked-in software, proprietary hardware, and brutal economics.
Legacy code and single-vendor dependency
Custom industrial software was often built against specific APIs and drivers available at the time. When the vendor vanishes or the developer retires, the application becomes a black box. Porting it to a new OS requires reconstructing its logic, which can cost six or seven figures and months of downtime. In Huber’s case, the egg-sorting software is niche to the point of being irreplaceable without a ground-up rebuild.
Hardware compatibility and peripheral traps
Many legacy systems depend on serial/parallel I/O cards, proprietary sensors, and ancient printers that lack drivers for modern Windows versions. The old Brother printer in Huber’s setup exemplifies this: if it fails, finding a replacement that speaks the same driver language may be nearly impossible. Emulators and virtualization can help, but hardware passthrough remains fragile.
Capital economics and the “if it ain’t broke” creed
The machine sorts eggs—physically and reliably. Huber’s calculation is straightforward: a new sorter costs more than a house, while the existing one plus Windows 95 continues to perform its core function. This pragmatic arithmetic repeats across industries where specialized equipment outlives its software’s support lifecycle.
The hidden risks: security, compliance, and catastrophic failure
Comfort in the status quo obscures a cascade of dangers that can turn a cost-saving decision into a financial disaster.
Security exposure
Windows 95 hasn’t received a patch since December 31, 2001. If that machine ever touches a network—even briefly—it’s a soft target for automated exploits. Isolated or air-gapped setups reduce the risk, but a single misconfiguration or a USB stick can compromise decades of production data. As industrial control systems increasingly interconnect, one unpatched node can become a pivot point for ransomware attacks that paralyze entire operations.
Supply-chain and maintainability risk
The sole maintainer is gone; the source code likely lost. If the application corrupts its data or a peripheral fails, recovery becomes an archaeological dig. Every day that passes without a migration plan deepens the dependency on obsolete hardware that can’t be sourced from first-tier suppliers. Dead CMOS batteries, failing power supplies, and disk degradation are statistical certainties over a multi-decade timeline.
Regulatory and traceability concerns
Food safety laws demand accurate, tamper-proof records. An unmaintained, undocumented logging system invites audit scrutiny. If regulators can’t verify data integrity or backup procedures, the farm could face fines, forced downtime, or liability in the event of a recall. Modernizing logging to a format like CSV or SQL—even while the legacy app remains—is a low-cost way to mitigate this.
Environmental and catastrophic risk
Spare parts for 1990s PCs are now museum pieces themselves. A power surge, a roof leak, or simple aging can knock the system offline permanently. Without a fallback machine or a disk image, a single component failure could mean weeks of lost production and an emergency replacement that dwarfs the cost of planned modernization.
How to modernize without breaking eggs
For Huber and thousands of other legacy system operators, the path forward isn’t binary. There are staged, cost-effective options that reduce risk without requiring a forklift upgrade.
Option A: Harden and isolate (low immediate cost)
Physically air-gap the PC, put it on a dedicated VLAN with no internet access, disable all unnecessary services, and enforce strict access controls. Create a full disk image and stockpile spare hardware—an identical PC, power supply, and printer—while they’re still on eBay. This buys time but doesn’t remove the underlying fragility.
Option B: Virtualize (moderate cost)
Take a bit-by-bit image and run it inside a controlled virtual machine on a modern host. Use USB/serial passthrough for printer and I/O devices. This centralizes backups and snapshots, but hardware passthrough can be unstable, and legacy drivers may refuse to cooperate. Thorough testing with actual production loads is essential.
Option C: Rebuild or wrap the application (higher cost, long-term payoff)
Reverse-engineer the I/O paths and data formats, then build a modern service that replicates the essential functions: reading sensor inputs, generating labels, and logging compliance data. A shim layer can translate legacy outputs to modern databases or APIs, preserving the physical sorter while cutting the dependency on Windows 95. This requires engineering investment but yields a maintainable system that meets today’s regulatory standards.
Option D: Replace the entire machine (capital-intensive)
When the sorter is near end-of-life or the risk profile is intolerable, rip and replace. A new integrated solution brings vendor support and modern security, but it’s costly and may sacrifice custom features that the old machine accumulated over decades.
A broader lesson in platform longevity
Windows 95’s endurance isn’t just a German egg farm story—it’s a microcosm of how industrial systems lock in technical debt. The very features that made Windows 95 a smash hit in 1995—broad hardware compatibility, low resource requirements, and a user-friendly GUI—are what make it sticky 30 years later. The same forces are at work today with Windows 10, whose imminent end-of-support in October 2025 has millions of users facing a choice: upgrade to Windows 11 on hardware they may not trust, or stay put and accumulate the same risks Huber faces.
Backward compatibility is a double-edged sword. It encourages adoption and fosters an ecosystem of niche applications, but it also breeds complacency. When the cost of rewriting software exceeds the perceived risk of running unsupported systems, the default choice is inertia. History shows that waiting until hardware dies often forces a more expensive, chaotic migration than a planned one.
What we can verify—and what we can’t
Multiple sources confirm the core facts: Windows 95’s release date, support end dates, and the existence of Huber’s farm near Düsseldorf as reported by WDR. The PC Gamer article and additional German tech outlets corroborate the setup and Huber’s quotes about rebooting, printer dependency, and the cost comparison to a house. However, that cost comparison is a local estimate, not an industry benchmark. A modern egg sorter may cost less—or far more—depending on capacity and features. Treat Huber’s “as much as a house” line as a heuristic, not a price quote.
Practical takeaways for IT managers and small operators
- Document everything—hardware specs, software builds, data formats, connectors—before it’s too late.
- Create a bit-for-bit disk image and verify it by booting in a safe environment.
- Isolate legacy machines on firewalled subnets with no internet access and restricted physical access.
- Export critical data to immutable, modern formats (CSV, SQL) regularly so traceability survives an OS collapse.
- Stock spare parts and a fallback machine that can be swapped in within hours.
- Test virtualization with I/O passthrough; if it works, you’ve bought years of breathing room.
- Budget for a phased modernization—spread costs across multiple fiscal periods rather than gambling on a single capital event.
- Assume the legacy device is compromised and treat it accordingly: no USB drives, no unverified media, no relaxed firewall rules.
The bottom line
The Düsseldorf egg-sorting machine is a charming throwback, but it’s also a warning shot for every business running mission-critical processes on unsupported software. The choice between short-term savings and long-term resilience isn’t just about eggs—it’s about the viability of entire operations. With a reasoned, staged approach—imaging, isolation, virtualization, then selective modernization—operators can keep the eggs rolling while gradually shedding the risk that Windows 95 carries. Because sooner or later, that faithful Brother printer will sputter its last page, and the only thing harder than upgrading now will be upgrading in the middle of a crisis.