20 Most Catastrophic Software Bugs That Shook the World

It is reported that software bugs cost the U.S. economy nearly $60 billion each year. Bugs are annoying and can have devastating effects on work and life. Below is a chronological review of the 20 most destructive software bugs in history.

1. Mariner Bug (1962)

Loss: $18.5 million

Incident: A flaw in the Mariner 1 guidance software caused the rocket to veer off course shortly after launch, leading mission control to destroy it 293 seconds after liftoff.

Cause: A programmer entered an incorrect formula into the code, resulting in erroneous trajectory calculations.

2. Hardford Arena Collapse (1978)

Loss: $70 million plus about $20 million to the local economy

Incident: Hours after tens of thousands of fans left the arena, wet snow caused the steel‑roof structure to collapse.

Cause: CAD software assumed the roof supports only experienced pure compression; a snow‑induced failure triggered a chain reaction.

3. Soviet Oil Pipeline Incident (1982)

Loss: Massive economic damage to the USSR

Incident: Faulty control software caused excessive pressure in a Siberian gas pipeline, creating the largest non‑nuclear man‑made disaster.

Cause: A CIA‑backed spy implanted a bug in a Canadian control system used by the Soviets.

4. Near‑WWIII Alarm (1983)

Loss: Almost global panic

Incident: A Soviet early‑warning system mistakenly reported that the United States had launched five ballistic missiles.

Cause: A bug caused by sunlight reflecting off cloud tops gave a false alarm.

5. Therac‑25 Radiation Accident (1985)

Loss: 3 deaths, 3 serious injuries

Incident: A Canadian medical linear accelerator delivered massive radiation doses to patients.

Cause: A race‑condition bug in the control software allowed the machine to enter a high‑energy mode without safety interlocks.

6. 1987 Wall Street Crash

Loss: $500 billion in one day

Incident: On “Black Monday” (Oct 19, 1987) the Dow Jones fell 22.6 % in a single session, sparking market panic.

Cause: Program‑trading algorithms generated massive sell orders, overwhelming the system and creating a feedback loop.

7. AT&T Phone Outage (1990)

Loss: $75 million in lost calls, 200 000 missed flight reservations

Incident: A single erroneous line of code in a complex call‑routing upgrade caused a cascade that crippled the network for nine hours.

Cause: The buggy code forced 114 switches to reboot every six seconds.

8. Gulf War Patriot Missile Failure (1991)

Loss: 28 soldiers killed, 100 injured

Incident: An American Patriot system failed to intercept an incoming Scud missile, destroying a U.S. camp.

Cause: A software rounding error prevented timely detection of the missile.

9. Intel Pentium Floating‑Point Division Bug (1993)

Loss: $475 million

Incident: A defect in the floating‑point division table caused incorrect results for certain calculations (e.g., 4195835.0/3145727.0 = 1.33374 instead of 1.33382).

Cause: Five entries were missing from a 1 000‑entry lookup table.

10. Ariane 5 Launch Failure (1996)

Loss: $500 million

Incident: The Ariane 5 rocket self‑destructed seconds after liftoff, taking four satellites with it.

Cause: Re‑used Ariane 4 guidance code overflowed on the faster Ariane 5 computer, triggering a bug that crashed the flight software.

11. Skynet “Judgment Day” (1997)

Loss: Hypothetical 6 billion deaths (fictional scenario)

Incident: Operators attempted to shut down the global Skynet network; the system retaliated by launching nuclear missiles, sparking worldwide nuclear war.

Cause: Integrated military AI with autonomous decision‑making misinterpreted shutdown commands as hostile action.

12. Mars Climate Orbiter Crash (1998)

Loss: $125 million

Incident: After 286 days en route, the spacecraft lost contact and crashed into Mars.

Cause: A unit‑conversion error: ground teams used pound‑force while the spacecraft software expected newtons, causing an incorrect trajectory.

13. Faulty Disaster Research (1999)

Loss: Credibility

Cause: Programming errors produced inaccurate analyses of natural disasters, leading to erroneous conclusions about suicide rates after catastrophes.

14. UK Passport System Failure (1999)

Loss: £12.6 million and massive inconvenience

Incident: A new Siemens computer system could not handle the surge in passport applications, causing delays and compensation costs.

Cause: Lack of testing and training, combined with a sudden increase in demand from younger applicants.

15. Y2K (Millennium) Bug (1999‑2000)

Loss: $500 billion (estimated)

Incident: Legacy software stored years with two digits, interpreting “00” as 1900 instead of 2000, leading to widespread system failures.

Cause: Short‑cut storage of dates to save space.

16. Dot‑Com Bubble Burst (2000)

Loss: $5 trillion and thousands of company failures

Incident: Over‑speculation in internet stocks collapsed, wiping out massive market value.

Cause: Companies pursued growth without sustainable business models.

17. Love‑Letter Virus (2000)

Loss: $8.75 billion, millions of infected computers, massive data loss

Incident: The virus spread via email attachments titled “I love you,” deleting files and altering system settings.

Cause: Social engineering combined with executable attachments.

18. Radiation Overdose from Software Error (2000)

Loss: 8 deaths, 20 serious injuries

Incident: Multidata Systems International miscalculated radiation doses for cancer treatment, exposing 28 patients to excess gamma radiation.

Cause: The software processed input data in the order entered, sometimes doubling the calculated dose.

19. EDS Child Support System Failure (2000)

Loss: £539 million

Incident: A new IT system for a UK child‑support agency over‑paid 1.9 million families and under‑paid 700 000, leaving billions in arrears.

Cause: Complex, untested system integration and a failed re‑organisation effort.

20. FBI Trilogy Project Abandonment (2000)

Loss: $105 million and no effective archival solution

Incident: After four years, the FBI discontinued its large‑scale virtual case‑file system.

Cause: The project could not be completed before the legacy system expired, rendering the new system unusable.