Level Design Principles for 2D Platformers

Good 2D platformer level design rests on four rules: teach each mechanic in a safe space before you test it, space every jump to the player's real jump arc, build the level on rhythm instead of chaos, and guide the eye so the right path reads without a word of text. The platformer is the oldest, most refined genre in level design, and its conventions are forty years of hard-won craft. Get these four things right and your levels feel fair and flow; get them wrong and players call your game clunky without being able to say why.

This is the genre-specific deep dive. If you want the general process — goals, blockouts, the flow channel, playtesting — the level design tutorial covers it. Here we assume that process and look at what changes when the player moves by jumping.

The 4-step structure: teach, develop, twist, pay off#

Every well-taught mechanic in a good platformer follows the same four beats. Nintendo's Koichi Hayashida, director of Super Mario 3D World, described the method openly, and it maps onto kishōtenketsu, the four-act form from Japanese manga — introduction, development, twist, conclusion.

Beat	What happens	Platformer example
1. Introduce	The mechanic appears in a safe space where failing costs nothing	A new enemy on flat ground the player can simply jump over
2. Develop	The player must use the mechanic to progress	The same enemy blocks the only path forward
3. Twist	The mechanic combines with a second one, or comes under pressure	The enemy now patrols a narrow platform over a pit
4. Pay off	A challenge that rewards mastery, then a safe beat to breathe	A run of three enemies, then a checkpoint

The structure exists because players will not read a manual. If a hazard appears for the first time on the critical path with no warning, the death feels cheap; if it appears first where running into it costs nothing, the player learns the rule, and the next encounter feels fair. Super Mario Bros. World 1-1 is the canonical teaching level — every core mechanic shows up first where it cannot kill an unsuspecting player — but the named four-step method belongs to the 3D games that came later.

Your jump physics decide your level spacing#

In a platformer the jump is the verb, and the jump has a fixed shape. Before you place a single platform you should know exactly how far and how high the player can leap, because every gap, ledge, and floating block has to sit inside that envelope.

The clean way to fix the jump is to choose the values you care about and derive the rest. Pick the apex height you want and the time the player spends rising to it; gravity and the launch velocity fall out of the math. This approach — laid out in the GameDeveloper article Designing a 2D Jump and Kyle Pittman's GDC talk Building a Better Jump — means you tune the jump to feel right first, then design levels around numbers you actually control.

What you choose	What it decides
Apex height	How high walls and ledges can be
Time to apex	The floatiness of the jump; gravity and launch velocity
Run speed	The maximum horizontal jump distance
Coyote window	How forgiving a missed-edge jump feels

Once those are fixed, design by them. A gap wider than the maximum jump distance needs an intermediate platform or a moving one; a ledge higher than the apex needs a wall to climb or a lower route. Spacing a level by eye and hoping it is reachable is how indie platformers ship jumps no human can make.

Build on rhythm, not chaos#

A platformer level is closer to a piece of music than a map. Research on procedural platformers frames rhythm — the timing and repetition of the player's jumps — as the principle that makes a level feel good, and the best hand-authored levels follow a clear beat of tension and release. Jumps cluster, ease off onto a safe landing, then build again.

In practice that means vary the density. A stretch of tight, consecutive jumps should open onto a calm platform where the player can breathe and read the next challenge. A level that stays at maximum intensity the whole way through is exhausting; one that never rises is dull. The difficulty curve you would draw on paper is really a rhythm you feel in your hands.

Teach without text#

Players will not read instructions, so a well-designed level teaches through the space itself. The tool is signposting: arranging light, color contrast, movement, and landmarks so the golden path — the route you intend the player to take — reads at a glance.

The principle, drawn from the theory of affordances, is that the level should make the right action obvious. Coins trail in an arc over a gap to suggest the jump. The brightest accent color marks the exit. A landmark on the horizon orients the player when the path forks. When players keep going the wrong way, the level is telling you the signposting is wrong — not that the players are.

Forgive the player#

Even a perfectly spaced level will see mistimed input, and how a game handles it is the difference between tight and frustrating. Two standard techniques absorb honest mistakes:

Technique	What it does	Typical value
Coyote time	Lets the player jump for a brief moment after walking off a ledge	~0.1 seconds (about 6 frames at 60 FPS)
Jump buffering	Remembers a jump pressed slightly before landing and fires it on touchdown	~0.1–0.15 seconds

Coyote time — named for Wile E. Coyote running off a cliff — costs nothing and removes a large class of unfair-feeling deaths. Jump buffering does the same for players who press jump a frame too early. Celeste, often cited as a benchmark for platformer feel, ships both. For the wider craft of making actions land, the guide to making your game feel good goes deeper.

Reward exploration#

The golden path gets the player to the exit; the optional routes give them a reason to look around. A hidden alcove, a risky detour to a collectible, a secret area behind a fake wall — these are how a platformer repays curiosity without blocking players who just want to finish. Place rewards where the eye is drawn but the path is not obvious, and make the detour's risk honest: if a jump looks barely possible, it should be barely possible, with a real payoff if the player nails it.

Common mistakes#

Mistake	What goes wrong	What to do instead
Spacing jumps by eye	Gaps are unreachable or trivially easy	Derive the jump arc first; space every platform inside it
No safe introduction	A new hazard kills on first contact; the death feels cheap	Show every mechanic in a safe space before it is required
Flat intensity	The level never builds or releases tension	Vary the rhythm; break tight sequences with calm beats
Missing signposting	Players wander and blame the game	Mark the golden path with light, color, and landmarks
No forgiveness	Honest mistiming reads as instant death	Add coyote time and jump buffering
Secrets on the critical path	Players miss the reward, or feel forced to hunt	Keep the golden path clear; make secrets optional detours

How Egmatic fits#

Platformer level design lives and dies by iteration: move a platform, jump the gap, feel whether it lands, move it again. Anything that slows that loop — a long build, a slow import, a tool that fights you — slows the design itself.

Egmatic is built for that loop. Its 2D scene editor and live preview let you nudge a platform, run the jump, and feel the change in seconds rather than waiting on a build, which is exactly what spacing a level to its jump arc demands. The mechanics — when a jump fires, how coyote time behaves, what a hazard does on contact — are authored as visual logic and data, so tuning the feel is a quick edit, not an engineering task. If you want the foundations those levels are laid on, the 2D scene design guide covers how a platformer level is composed; the real-time preview guide covers why a fast feedback loop is the whole point.

Conclusion#

A great 2D platformer level is not a lucky arrangement of platforms. It is a four-step lesson that teaches each mechanic safely before it tests it, spaced to a jump arc you derived rather than guessed, built on a rhythm of tension and release, and signposted so the path reads without text. Forgive the player's honest mistakes with coyote time and jump buffering, reward exploration off the golden path, and iterate until the level feels fair. The genre's design language is forty years old and fully written down — the work is applying it, and applying it fast.

---

Sources#

1. The four-step level structure (introduction, development, twist, conclusion) and its link to kishōtenketsu, articulated by Koichi Hayashida for Super Mario 3D World — Mark Brown, Game Maker's Toolkit, Super Mario 3D World's 4-Step Level Design
2. The same structure explained as a four-act poetic form — Eurogamer: How Nintendo's Best Mario Levels Were Structured Using Chinese Poetry
3. Deriving gravity and launch velocity from a chosen apex height and time-to-apex — Designing a 2D Jump (GameDeveloper); Kyle Pittman, Building a Better Jump, GDC 2016
4. Rhythm as the underlying principle of platformer level design — Gillian Smith, Rhythm-based Level Generation for 2D Platformers (FDG 2009, ACM)
5. Affordances and how design makes the right action obvious — Donald Norman, The Design of Everyday Things
6. Coyote time and jump buffering as standard platformer forgiveness mechanics — GDQuest, Coyote Time; Kyle Pulver, Jump Input Buffering