Pac-Man, released in 1980, is one of the most played video games in human history. Hundreds of millions of people have guided that yellow circle around its maze, eating dots, fleeing ghosts.
Almost none of them have ever seen the game end. Not because they weren’t good enough — but because, in a very real sense, the game does not end. It breaks.
If a player is skilled enough and patient enough to reach Level 256, Pac-Man does not reward them with a victory screen, a congratulations, or a roll of credits. Instead, the right half of the screen dissolves into chaos — a jumbled wall of garbled letters, numbers, and meaningless symbols. The level becomes physically impossible to complete. The game simply stops being a game.
This is the famous “kill screen.” And the reason it exists comes down to a single number that Pac-Man was never able to count past.
The number 255
To understand the kill screen, you need one small fact about how old computers store numbers.
Pac-Man’s arcade hardware was built around an 8-bit processor. “8-bit” means the computer handled information in chunks of eight binary digits. And an 8-bit number has a hard ceiling. The largest value eight bits can represent is 255. Count one higher, and there is simply nowhere to put the next number.
When that happens, the value doesn’t keep climbing. It does something stranger. It “overflows” — it wraps all the way back around to 0, like a car odometer rolling over. 255 plus 1, in an 8-bit byte, equals 0.
Pac-Man’s programmers, working in 1980 when memory was scarce and expensive, chose to store the game’s current level number in a single 8-bit byte. It was a sensible decision. No one in 1980 imagined a human being patient enough to play 256 consecutive levels of Pac-Man. Why waste precious memory preparing for a level no one would ever reach?
But some players did reach it. And when they did, that small, sensible decision turned into one of the most famous bugs in gaming history.
What actually happens at Level 256
Here’s the mechanism, in plain terms.
Pac-Man’s level counter starts at 0 internally, so Level 256 is stored as the number 255 — the maximum the byte can hold. At the start of each level, the game runs a routine that draws the little fruit icons in the bottom corner of the screen, the ones that show your progress. That routine takes the level number and adds 1 to it.
On Level 256, it adds 1 to 255. The byte overflows. The number becomes 0.
And the fruit-drawing routine has no idea what to do with 0. It was never written to handle that case. So instead of drawing a tidy row of fruit, it goes haywire — interpreting unrelated data as if it were instructions for what to draw, and flooding the right half of the screen with garbage. Scrambled tiles. Stray letters. Random-looking symbols. A digital mess.
The corruption isn’t just cosmetic. To finish any level of Pac-Man, the player must eat 244 dots. But the corrupted right side of the screen contains only 9 dots. Add the 122 dots still on the intact left side, and the absolute maximum a player can eat is 131 — nowhere near the 244 the game demands.
The level, quite literally, cannot be completed. The requirement to advance is mathematically unreachable. The player can run around the broken maze as long as they like, but they can never clear the board. Level 256 is a door with no key.
That is the end of Pac-Man. Not a finale. A dead end.
The game behind the glitch gets strange
There’s a peculiar bonus to the kill screen, for the curious.
Because the corruption scrambles not just the screen’s appearance but parts of the maze’s collision data — the invisible rules about where walls are — Level 256 behaves unlike any other level in the game. Pac-Man can sometimes slip around the edges of the screen in ways the normal maze never allows. Vertical wrap-arounds, impossible everywhere else in the game, become briefly possible. The kill screen isn’t just broken — it’s broken in genuinely interesting, exploreable ways.
The bug was eventually analysed in detail by a programmer named Don Hodges, who not only worked out exactly what was going wrong, line by line, but wrote a small patch that fixes it — proving that with a few corrected instructions, Pac-Man could, in principle, count past 255 and keep going.
Why a 45-year-old bug still matters
It would be easy to treat this as a piece of gaming trivia. It’s more than that. The Pac-Man kill screen is one of the cleanest illustrations ever produced of a principle that runs through all of computing.
Every piece of software ever written contains assumptions — quiet decisions about how big a number could get, how long a name might be, how many times something could happen. Most of those assumptions are invisible, and most of them are fine. Right up until reality walks past the edge of what the programmer imagined.
Pac-Man’s programmers assumed no one would reach Level 256. It was a completely reasonable assumption. It was also, eventually, wrong — and the moment it was proven wrong, the game fell apart in exactly the spot where the assumption had been quietly holding everything together.
The kill screen has shown up since in other games as a deliberate homage, and it’s referenced across gaming culture. But the original remains the purest version. One byte. One ceiling. One number — 255 — that a 1980 arcade machine could not count past.
Pac-Man doesn’t have an ending because nobody wrote one. They didn’t think they needed to. And so the closest thing the game has to a final screen is the sight of it quietly breaking — the point where one of the most famous games ever made simply runs out of the numbers it needs to keep going.
