Jumpman: The Platformer as a Showcase for Its Own Level Editor

Jumpman’s job is to defuse bombs by touching them, and that is the entire stated objective across thirty levels. What Randy Glover actually built underneath that one-line premise is a demonstration, level by level, of how many different ideas a fixed grid of girders, ladders and ropes could support before the format ran out of tricks — and by level thirty, it had not run out.

Glover wrote it for Automated Simulations, the company that would rebrand as Epyx during the game’s own development, and released it for the Atari 8-bit computers in 1983 before porting it to the Commodore 64 himself. Climbing surfaces come in two distinct varieties — ladders that can be climbed in either direction and ropes that only permit movement one way — and Jumpman traverses a skyscraper’s worth of girder-and-ladder architecture across three separate buildings, defusing every bomb on a given screen while dodging patrolling bats, birds, aliens and robots that vary from level to level. It sold roughly 40,000 copies on the Atari and C64 combined by 1987 and reached as high as the middle of the Billboard top 100 games chart at its peak, a genuinely large number for a platform-puzzle game with no arcade pedigree behind it.

One verb, thirty arguments

The premise of touching bombs to clear them sounds almost too simple to sustain thirty levels, and that is exactly the point Glover was making by building thirty of them. Nearly every level past the first introduces its own distinct gimmick rather than simply rearranging the same furniture at a harder difficulty. Some levels feature platforms and ladders that appear or vanish the moment you collect a bomb, forcing you to plan a defusal route that accounts for the level reshaping itself mid-attempt. Others introduce moving platforms that require timing rather than pure navigation, or enemies with movement patterns specific to that one screen and nowhere else in the game.

That design choice, a fresh gimmick nearly every level rather than an escalating difficulty curve applied to a fixed toolset, is a much more expensive thing to build than it looks. It means thirty levels’ worth of individually bespoke design and testing, rather than one well-tuned system stretched across thirty difficulty settings. Most platformers of the period, even good ones, lean on the cheaper option. Jumpman did not, and the game reads today less like a single game with thirty levels than like thirty small design pitches sharing one avatar and one core verb.

The level as the actual unit of design

Because each level is doing its own distinct job, the experience of playing through Jumpman end to end is closer to flipping through a portfolio than climbing a single difficulty ramp. A level built around vanishing platforms asks you to read the level’s memory rather than its geometry — which bombs have you already taken, and what has that changed. A level built around a moving elevator platform asks you to read timing rather than memory. A level with a swarm of patrolling creatures asks you to read threat density and plan a route that avoids convergence rather than confrontation.

This matters because a platformer’s difficulty can come from at least two very different places: harder execution of the same skill, or a genuinely new skill applied to familiar-looking scenery. Jumpman leans hard on the second, and the result is a game that stays interesting screen to screen rather than becoming a test of whether you have simply gotten faster at the same jump.

A game built to be reverse-engineered

The original 1983 release shipped with no official level editor — its thirty levels were entirely Glover’s own hand-built work, and anyone wanting to make more had to work directly with the game’s binary level format, without a supported tool. What made that possible at all was the same discipline driving the level design itself: a small, clean grid-based grammar of girders, ladders and ropes, consistent enough across all thirty levels that hobbyists could eventually reverse-engineer the format entirely. Community tools such as the Omnivore editor now let anyone build new Jumpman levels from scratch on the original engine’s own terms, decades after Glover stopped working on it.

The more direct inheritor of that idea shipped properly eight years later. Jumpman Lives!, an unofficial spiritual sequel from Apogee Software released in 1991, kept the girder-and-ladder premise and finally built the official level editor the original format had always seemed to be inviting, shipping it alongside four new episodes of content. That a level format this disciplined could sit dormant for the better part of a decade before someone built the toolset it was practically begging for says something about how well Glover’s original grammar held up on its own terms, needing no editor to already feel like a construction kit in spirit.

The girder-and-ladder grammar

The underlying grammar — girders you walk along, ladders you climb in either direction, ropes you climb in only one — is a small, disciplined vocabulary that every level reconfigures rather than expands. That restraint is what makes the constant gimmick-swapping legible rather than exhausting: because the base movement grammar never changes, a player can drop into level twenty-five and immediately understand what Jumpman is capable of doing, even if working out what the level wants takes longer. The gimmicks live entirely in the level layout and the enemy behaviour, never in a new control scheme you would have to relearn.

That separation, a fixed player vocabulary against an ever-changing level vocabulary, is the exact structural idea Lode Runner was solving from a different angle the same year, using a dig mechanic instead of a climb mechanic to generate its own variety from a small rule set. Both games understood that the fastest way to make thirty screens feel individually considered is to keep the player’s toolkit small and put all the design effort into what that toolkit is asked to do.

A company rebranding mid-project

Glover built the game for Automated Simulations, a company that renamed itself Epyx during Jumpman’s own development window — a small piece of studio history that says something about how quickly the American home-computer software business was reinventing itself in the early eighties, sometimes faster than a single project could be finished under one name. The rebrand did not change the design brief: Epyx wanted a platform game that could show off the newly expanded RAM available on the Atari 800, and the thirty-level structure was itself a direct response to that larger memory budget rather than an arbitrary round number. More levels were possible, so Glover built more levels, and then made sure each one earned its place rather than simply padding out the available space.

The other side of that same architecture is Jumpman himself, whose jump arc, climb speed and collision behaviour never vary across any of the thirty screens. A player who has mastered the physics on level three already knows everything they need to know about level twenty-eight’s physics — the only thing left to learn is what that particular screen has decided to do with them. That consistency is what makes the constant gimmick-swapping feel like variety rather than a moving target; the ground never shifts under the player’s own competence, only the furniture around it does.

Why this still reads as generous design

The habit of the era was often the opposite: pad a simple platformer with sheer distance, or reskin the same handful of screens with palette swaps and call it new content. Jumpman’s insistence on a distinct idea nearly every level is generous in a way that costs the designer more than the player ever sees, and it is the reason the game held a chart position for as long as it did against competitors offering flashier single-screen spectacle but far less actual variety underneath.

It is also a lesson that did not get inherited as cleanly as it deserved. Bounty Bob Strikes Back, a slightly later platformer built from a similar girder-and-ladder DNA, took the opposite approach to its own difficulty and became notorious for punishing precision over introducing fresh ideas — a reminder that the genre’s two available levers, new gimmick or harder execution, produce very different reputations depending on which one a designer leans on.

The lesson for anything with a level format

The broader point Jumpman makes, almost by accident, is that a level format designed cleanly enough for its original author to move fast within it is also a level format an outside community can eventually learn to speak. That is not a given — plenty of period platformers hard-coded their level data in ways nobody outside the original studio ever cracked. Glover’s grid-based grammar happened to be legible enough, decades on, for hobbyist tools to open it back up, which is a kind of longevity no amount of marketing copy about a “level editor” could have manufactured at launch.

Where to play it: the Atari 8-bit original is where Glover’s full thirty-level vision first shipped, and the Commodore 64 port, which he also handled personally, carries the same level set with the C64’s own sprite-and-sound signature layered over it.

Spoilers below

The third and final building escalates the vanishing-platform and moving-hazard gimmicks introduced earlier into combinations the first two buildings never attempt together on a single screen, which is the closest the game comes to a difficulty spike rather than a lateral gimmick swap. There is no story beat or ending cutscene to spoil — clearing the final bomb on the final level simply resets the loop at a harder difficulty tier, in the arcade tradition of the period, which means the game’s real “ending” is the moment a player realises the thirty original levels were the entire authored content and everything past that point is repetition with sharper teeth.