5 Bombs — Divide by Zero
Atari Atari ST
Severity: CriticalWhat Does This Error Mean?
Five bombs on an Atari ST mean the 68000 CPU attempted to divide a number by zero. This is a programming bug in the software — a calculation produced a zero divisor that was not checked. Reset the computer and try the software again. If it recurs, the bug is consistent.
Affected Models
- Atari 520ST
- Atari 1040ST
- Atari STe
- Atari TT030
- Atari Falcon030
- Hatari emulator
- STeem emulator
Common Causes
- Software bug — a variable used as a divisor reached zero without being checked
- Uninitialised variable defaulting to zero used in a division
- Game or demo encountering an edge case the developer did not anticipate
- Corrupt data file causing unexpected zero values in calculations
How to Fix It
-
Reset the Atari ST and retry the operation.
Divide-by-zero crashes are usually triggered by specific conditions in the software. Restarting and avoiding the exact same sequence of actions may prevent the crash.
-
If the crash happens at a specific point in a game, try a different approach.
Some game bugs only trigger under specific conditions — a particular level, score, or action. Playing differently (different route, different weapon) can avoid the buggy code path.
-
Check if a patched version of the software is available.
Many Atari ST games and applications were updated after release to fix crash bugs. Check Atari ST archives and fan sites for updated versions.
-
On Hatari emulator: use the built-in debugger to identify the failing instruction.
Press the Pause key in Hatari to enter the debugger. The program counter shows where the crash occurred, which helps identify the bug if you are developing your own software.
Frequently Asked Questions
Can a divide-by-zero crash damage my Atari ST?
No. A divide-by-zero is a software error handled by the CPU's exception system. It halts the program and shows the bomb screen, but causes no hardware damage whatsoever.
Why does the 68000 CPU crash on divide by zero instead of returning an error?
The Motorola 68000 treats division by zero as a hardware exception — it immediately stops the current instruction and jumps to an exception handler. This is a CPU design choice. Higher-level languages can catch it, but if the OS does not install a handler, you get bombs.