The vocabulary, frameworks, mechanics, level design, genres and patterns a game designer needs — with an eye on 2D & pixel-art indies (but not only). Essential, scannable definitions, with pointers to deep-dives.
Mechanics → Dynamics → Aesthetics. The designer builds the rules; from the rules emerge in-game behaviors; from these arise emotions. The player, though, experiences it in reverse: they feel the emotion first.
Hunicke, LeBlanc, Zubek (2004) · the most cited lens for reasoning about levels of abstraction in design.
The cycle of actions the player repeats. It must be fun on its own, before content and story.
"30 seconds of fun" (Bungie/Halo): if the basic loop holds for half a minute, it holds for the whole game.
Character, Camera, Control: the trinity of "feel" in action games. Nail these first — they're what the player touches every instant.
Responsive character + readable camera + responsive controls = a solid base to build anything on.
The fundamental actions: jump, shoot, talk, build. Design around a few strong, combinable verbs.
Mechanics are the rules; verbs are what the player does. One deep verb (e.g. Mario's jump) is worth more than ten shallow ones.
Affordance: the action an object makes possible. Signifier: the visual cue that communicates it.
A glowing ledge "says" climbable; a wooden crate "says" breakable. A consistent visual language = no confusion.
Don Norman, "The Design of Everyday Things".
Every action wants a reaction (visual + audio): without feedback the game feels "dead".
Telegraphing: warning the player of what's about to happen (the enemy's wind-up, the flash before an attack) so the challenge is fair.
Agency: the player feels their decisions matter. A choice is meaningful when it is:
Emergent: complex behavior from simple interacting rules (systems, "chemistry"). Scripted: hand-written sequences.
For an indie, emergence is often more efficient: little authored content, lots of varied play.
Keep the challenge aligned with growing skill: too hard → anxiety, too easy → boredom. In between lies the flow channel.
Difficulty doesn't rise in a straight line: it oscillates (peaks + breathers) following the learning curve.
Mihály Csíkszentmihályi, "Flow".
LeBlanc's taxonomy — why people play:
Replaces the vague "fun": it clarifies what kind of pleasure your game offers.
The "skeleton" that makes something a game (Tracy Fullerton's model):
If one of these is missing, it's probably a toy or a simulation, not a game.
Rules define the possible; constraints make the "how" interesting.
A well-chosen constraint generates more gameplay than one more rule.
Terminal conditions and "state" define the structure.
Clear defeat + fast restart = a challenge that invites another try.
Two opposite, complementary compasses.
Every mechanic should widen the right space and serve the right fantasy.
If a feature doesn't fit the core fantasy, it's often scope you don't need.
Distinguish the player's skill from the avatar's (stats).
The classic ideal: "easy to learn, hard to master" — low floor, high ceiling.
Player skill vs avatar skill: decide how much the thumbs matter and how much the build.
Agency is real only if the player understands what to do and what will happen.
A choice in the dark is just luck; an informed choice is design.
When you play, you step into a separate "space" where its own rules apply, accepted by consent.
It explains why we behave "differently" in play, and gives weight to the pact with the player.
Nicole Lazzaro's model: four kinds of "fun" tied to different emotions.
"Fiero" is the face (and the fist-pump) of someone who just overcame something hard.
A core mechanic defines the game; secondary ones support it. Don't dilute: better one mechanic explored deeply than ten sketched.
Test: if you remove that mechanic, is it still the same game? If not, it's the core.
More risk → more reward keeps tension alive and rewards mastery. Always leave the player the choice of how much to dare.
Push-your-luck: you keep accumulating until you lose it all. A very powerful tension engine (e.g. roguelites, loot slots).
"Invisible" assists that make controls feel right even when input isn't perfect:
coyote time — you can still jump ~5 frames after leaving the edgejump buffering — a jump pressed just before landing still firesvariable jump height — height based on how long you holdapex modifier — more control at the peak of the jumpcorner correction — forgives ceiling cornersCeleste and Super Mario are the living manuals of these tricks.
Small effects, big perceived impact:
Steve Swink, "Game Feel" · talk "Juice it or lose it" (Grapefrukt).
The camera is a silent designer: it decides what you see and when.
Health, ammo, currency, stamina, energy: scarcity generates interesting decisions.
Key questions: how is it earned? How is it spent? What do you give up by using it now? A resource without tension is just a number.
Creates content with rules + RNG (rooms, levels, loot). Use a seed to make it reproducible.
Trap: the "all-the-same" output. Fix: hybrid — hand-designed rooms/pieces assembled procedurally (e.g. Spelunky, Dead Cells).
The first layer of "feel": how intention becomes action.
See also "Platformer movement tech" for coyote time and jump buffer.
Each device has a different "grammar": design for the primary one.
Supporting a few inputs well > supporting many poorly.
Tools to give rhythm and depth to actions.
Collectibles are immediate rewards and pacing levers.
Mario's mushroom teaches: a pickup can redefine the whole state.
The mechanical heart of stealth is the enemy's information.
See the "Stealth" genre; the readability model is Mark of the Ninja.
When physics simulation is the gameplay, not just decoration.
Examples: Angry Birds, World of Goo, Human: Fall Flat.
In many games the score isn't decoration: it's the mechanic that pushes you to take risks and "play well".
A good scoring system turns "surviving" into "mastering".
In turn-based games the design lives on how many actions you get and in what order you act.
One action more or fewer per turn flips the whole balance.
Beyond the "assists" (coyote time & co.), movement is made of verbs that define the game.
Every new movement ability opens up new spaces and situations (see metroidvania).
How you represent life and damage changes the feel, tension and rhythm of combat.
Discrete hearts make every hit readable; bars + regen change the risk entirely.
How the game turns "point at the enemy" into a hit defines precision and accessibility.
Good aim assist is invisible: it helps without the player noticing.
A 4-beat structure (the "Kishōtenketsu" of Mario levels):
A good level is an invisible tutorial: no text, just space.
Alternate tension and breathing room, action and calm. Difficulty draws a sawtooth profile: peaks followed by descents.
Monotony kills more than difficulty: vary threats, spaces and intensity.
Distinguish the main path (the readable "golden" route) from branches (secrets, shortcuts, rewards).
Reward explorers: optional content adds depth without blocking those who just want to finish.
Block progress until the player has the "key": an item, an ability, or mastery.
Smart backtracking makes the map "grow" over time.
Guide the eye with light, color, leading lines, contrast and composition. The player goes where their gaze leads.
Landmarks (a tower, a neon sign) orient and give a sense of place. In 2D: silhouettes and accent colors in the background.
Form first, art later. Build the level with grey boxes and test the gameplay until it works.
Art applied too early makes changing the layout painful. Playable layout → then dress it.
Planning tool: the beat chart (a beat-by-beat map of emotions and intensity).
Place saves generously in hard stretches: repeating 5 seconds motivates, repeating 5 minutes makes people quit.
Rule: what you lose on death must be proportional to the mistake made, not punitive at random.
Always communicate the same way: danger (red spikes), safety, interactable, fragile.
If spikes are deadly in one spot and harmless in another, you've broken the trust pact with the player.
Designing the space of a fight, not just the enemies.
Space is measured in the character's abilities: metrics first, then levels.
Build a "metrics test room" and tune every gap against it.
Let the map "breathe" by connecting it back to itself.
Reward curiosity without penalizing those who go straight.
A found secret should give the right "dopamine hit", not just text.
Movement and jumping at the center of everything. Subgenres:
Super Mario remains the absolute reference for jump "feel".
An interconnected map explored non-linearly, unlocked by abilities (ability-gating) with backtracking.
Loop: explore → find ability → backtrack → open new paths.
You advance by scrolling and pummel crowds of enemies: combos and crowd control. Often local co-op.
1v1 combat: spacing, frame data, mind games. High mastery threshold.
Acrobatic combat, deep combos, style rewarded with score.
Not to be confused with the ARPG à la Diablo (there the heart is the loot).
Avoid rather than confront: patrols, visibility, patience. Tension comes from information (what the enemy knows).
Automatic scrolling: you dodge bullets and shoot. Grazing, bombs, patterns to memorize.
You move and aim independently (two sticks / WASD + mouse). Often fused with the roguelite.
Methodical and punishing combat: stamina, bonfires/checkpoints, cryptic lore, "die and learn".
Term born from Dark Souls (FromSoftware).
First-person action. Very different subgenres:
For indies the boomer shooter strand is a lively niche.
Many players, a strong multiplayer component and meta-economy.
Turn-based (or ATB), a party, a strong linear story. Today often in HD-2D style (sprites + 3D).
Deep choices, rich systems, a reactive world, free-form builds. Text and consequences at the center.
Real-time combat + loot + growth. Heart: "kill → loot → upgrade".
Grid-based tactical battles: positioning, turns, often permadeath.
You explore dungeons (often first-person, grid-based), map them, manage party and resources step by step.
Catch, raise and evolve creatures; teams, types, battles (often turn-based).
Turn-based, on a grid, ASCII/tile, permadeath, no meta-progression (Berlin Interpretation). Enormous depth, steep curve.
Procedural runs + persistent meta-progression across deaths: "every death makes you stronger/better".
Growing hordes, automatic attacks, pick upgrades, survive N minutes. Little input, lots of progression: perfect for indie/pixel.
Subgenre that exploded from 2022: young and crowded.
You build a deck and exploit synergies; the engine is the emergent combos.
Gather, build, command armies in real time: micro + macro together, high pressure.
You think without rushing. 4X = eXplore, eXpand, eXploit, eXterminate. "One more turn" depth.
Defend a path by placing turrets; escalating waves. Economy + positioning + damage types.
Competitive, derived from Warcraft/Dota mods.
Auto-battler = draft + positioning; MOBA = lanes + abilities.
Daily life: you farm, build relationships, relaxed pace. Often "cozy".
Manage a colony/base with many interconnected variables: emergent chaos IS the content.
Build cities/parks/businesses and optimize flows and profits. Economic balancing at the center.
Deep, consistent systems: many ways to solve every situation, freedom to the player. It's a design philosophy more than an aesthetic.
Gather resources, craft, build, survive; often open-world with a day/night cycle and hunger.
You manipulate shapes, blocks or physics. Simple rules, combinatorial depth.
Pure reasoning, no rush: the goal is the mental "click", not trial and error.
You build machines or "programs" that solve the problem; satisfaction = efficiency, multiple solutions.
Explore scenes, collect items, solve puzzles, dialogue. Writing and atmosphere at the center.
Text-based story + choices + branches; minimal or hybrid gameplay. Ideal for small teams (little "system", lots of writing).
You explore a place and reconstruct a story; little or no challenge. Environmental storytelling at its peak.
Scarce resources, vulnerability, oppressive atmosphere. Fear comes from powerlessness + scarcity, not jump scares alone.
Input in time with the music; score = precision. Fusing it with other genres is a goldmine for indies.
Simulation or arcade of sports/driving. For small teams, arcade > sim.
Automatic/exponential progression: you optimize and "let it run". It's numeric-curve design in its purest form.
See the "Numeric curves" card in Systems.
Few buttons, lots of chaos on the couch or online. The fun comes from the interaction between people.
No pressure or punishing failure: comfort, creativity, calm. A category of tone more than mechanics — fast-growing and very indie.
A genre sets the player's expectations and a shared vocabulary. Knowing it lets you: respect its useful conventions, break them on purpose, and position your game in the market (store, tags, wishlist).
The frontier comes from crossovers — for an indie, the unexpected crossover is often the winning idea:
Recurring conventions (the "implicit promises") of:
Respect the genre's base promises, then break one on purpose.
What the audience expects:
Mandatory element: the feeling that "this run is different".
Pure-thinking genres:
Promise: the challenge is fair because you have all the information.
Three tones, three different pacts with the player:
Getting the tone wrong (a "punishing" cozy) betrays expectations.
The right genre is a decision of scope and market, not just taste.
Know the genre's promises and mandatory elements before breaking them.
Think in terms of faucets (resource inflows) and sinks (outflows). The balance between the two keeps the economy healthy.
Too many faucets / too few sinks → inflation: currency loses value and tension fades. Add sinks (repairs, upgrades, consumables).
How the player grows: XP/levels, skill tree, gear/loot, unlocks.
Horizontal progression ages better: it gives variety, not just bloat.
Goal: viable diversity, not identical options. Avoid the dominant strategy that makes everything else useless.
Put the numbers in a spreadsheet: balancing is also math.
Input randomness (before the choice, e.g. a generated map): perceived as fairer, it's material to reason about.
Output randomness (after the choice, e.g. hit %): can feel unfair. Mitigate with a pity timer / pseudo-RNG that smooths unlucky streaks.
Static modes (Easy/Hard) vs DDA (dynamic difficulty adjustment, rubber-banding) that adapts in real time.
Assist options (extra lives, slow time) widen the audience without cheapening the challenge for those who want it.
Celeste — Assist Mode: a case study in inclusive difficulty.
How costs and rewards scale:
Often linear rewards + exponential costs = a sense of progress without breaking.
Positive: whoever is ahead pulls even further ahead (snowball) — thrilling but can end the match too early.
Negative: helps whoever is behind (Mario Kart's "blue shell") — keeps matches close. Dose both depending on the experience you want.
When and how you save defines tension and respect for the player's time.
How you handle death determines motivation or abandonment.
Celeste: harsh death, instant retry, zero redone ground.
The heart of ARPGs and survival: find, manage, equip.
See "Tables: spawn, loot, enemy" in Technical Design.
Customization systems that give expression and replayability.
Optional objectives that extend the game's life.
The best achievements teach you to play better.
The progression that lives between sessions.
Too much meta = "win by waiting"; too little = discouraging.
Balance chance with skill, and let the systems tell stories.
RimWorld and Dwarf Fortress: systemic chaos IS the content.
Adding other players changes everything: social, technical and moderation design.
Multiplayer is also infrastructure and community: for a solo dev it's the most expensive path.
Measuring and evolving bonds with characters and factions is a mechanic, not just writing.
Tie the numbers to the story: every affinity level should "say" something.
When the player builds in space, the placement rules are the mechanic.
Survival, colony/city builder, tower defense: space becomes a puzzle.
Time as a resource or a setting: it sets rhythm, pressure and opportunity.
Decide whether time always flows, only with actions, or stops when needed.
In games, structure must bend to interactivity: the player is not a spectator.
Tell the story through the world, not exposition: ruins, left-behind objects, writing on walls, "frozen" scenes.
The player reconstructs the story by observing — stronger participation than a read-out dialogue.
Dark Souls, Gone Home, Hollow Knight.
Embedded: a story pre-written by the authors (cutscenes, dialogue).
Emergent: arises from the game itself, unrepeatable, told by the player ("that time when…"). E.g. Dwarf Fortress, RimWorld, immersive sims.
Consistency (or conflict) between what you do and what the story says. If the character is "peaceful" but slaughters hundreds of enemies, there's dissonance.
Seek harmony: gameplay should express the theme, not contradict it.
Term coined by Clint Hocking about BioShock.
Diegetic: exists in the game world (a sign, a radio, Dead Space's hologram backpack).
Non-diegetic: only for the player (HUD, bars, soundtrack). Diegetic UI = more immersion, less "screen".
Show through action and detail instead of explaining. Iceberg theory: for everything visible, hint at a world beneath.
A consistent world (rules, aesthetics, lore) creates credibility even with very little — ideal for an indie.
A living character has a want, a need and an arc; and a recognizable voice.
Linear dialogue (strong writing, direction) vs branching (agency, choice & consequence). More branches = more cost: dose it wisely.
Structuring objectives that interweave gameplay and story.
Choices that truly matter (see "Agency & meaningful choice").
One visible consequence is worth more than ten invisible branches.
Characters and lines that do double duty: gameplay + character.
How to deliver world and story in small doses.
Show, don't tell: the iceberg suggests more than it states.
Making story and a repetitive structure (roguelite, sim) coexist.
Hades: every death advances the story instead of interrupting it.
The consistency that holds everything else together.
Pick a base resolution and design everything to it (e.g. 320×180, 256×224, 384×216). Draw sprites at their native size, not large "to shrink down".
Keep a consistent pixel density: no sprites at different resolutions in the same scene.
Work with limited palettes (NES, PICO-8's 16 colors, or a custom one). Build color ramps for shading.
Hue shifting: in shadows shift toward cool colors, in highlights toward warm ones — don't just darken/lighten the brightness.
lospec.com for palettes · Pixel Logic by Michael Azzi.
Scale only by integer multiples (2×, 3×, 4×): fractional scaling creates "dirty" pixels.
Avoid sub-pixel positions (jitter): round sprite and camera positions. In Godot use pixel snap and a fixed-resolution viewport.
Dithering: you alternate pixels of two colors to simulate gradients/shading with few colors.
Manual anti-aliasing: intermediate pixels placed by hand to soften curves and diagonals. Use it sparingly, where readability needs it.
Few frames, well chosen. Key poses before in-betweens.
Tutorials: Saint11 (Pedro Medeiros) · tool: Aseprite.
A good silhouette is recognizable even all-black. A fundamental test for characters and enemies.
Ensure contrast between foreground and background (the background should be desaturated/darkened) and use selective outlines to separate subjects.
Create seamless tiles and transition sets between terrains. Autotiling (47-tile blob / Wang tiles) picks the right tile automatically at edges.
Tools: Tiled, Godot TileMap / TileSet with terrains.
Techniques that give depth and atmosphere to 2D:
Organize animations for clarity and frame economy (few, well-chosen frames).
idle · walk · run · jump · fall · attack · hit · deathplayer_run_01) for clean importingTool: Aseprite (tags per state, atlas export).
Collision often does NOT match the sprite: separate them.
In Godot: TileSet with physics/terrain layers and custom data.
What matters isn't the still sprite, but how it reads in motion.
Communicate hits and events with readable, disciplined effects.
Audio + animation + VFX consistency = convincing impact.
Give depth to a flat scene with layers.
Keep decorative foreground transparent or out of the action zones.
Pixel-art interfaces that stay readable and well scaled.
See the UX & UI category for hierarchy, HUD and distance readability.
A state of total immersion. Conditions: clear goals, immediate feedback, balance between challenge and skill.
Stay in the "flow channel": raise the challenge as the player improves, or you lose them to boredom/anxiety.
Csíkszentmihályi, "Flow".
Self-Determination Theory identifies 3 needs that drive play:
Intrinsic motivation retains better than extrinsic (rewards).
Fixed ratio (a reward every N actions) vs variable ratio (an unpredictable reward). Variable — the "slot machine" — is the most engaging.
⚠️ It's also the most manipulable (loot boxes, dark patterns). Use it ethically: fun, not exploitation.
Bartle's model: Achiever (complete), Explorer (discover), Socializer (relate), Killer (dominate).
Design for several motivations at once. A modern, granular reference: Quantic Foundry's motivations.
Introduce mechanics one at a time (progressive disclosure). Too much at once = overload and quitting.
The first minutes (FTUE) decide whether the player stays: teach by playing, not with walls of text.
More audience + an ethical choice. Include:
Levers that move behavior (handle with care):
Tell them apart from toxic compulsion loops: aim for healthy engagement.
A challenge is accepted only if it's perceived as fair.
"Hard but fair" retains; "unfair" drives players away.
Not all frustration is bad.
Defeat should point the way, not slam a door.
The pleasure of learning and then mastering.
A good game makes you feel smarter/more skilled than yesterday.
Why the player comes back tomorrow — in a healthy way, not compulsively.
Stardew Valley: "just one more day" comes from many small open purposes.
How the player assesses danger and progress moment by moment.
See "Motivation (SDT)" and "Risk & reward".
The same levers that motivate can exploit: the difference is intent.
Ask: does this feature serve the player's fun or their exploitation?
Player needs change over time: design for the different phases, not just "day one".
Someone one hour in and someone a hundred hours in want different things: serve both.
3–5 guiding principles that describe the essence of the game (e.g. "constant tension", "joyful movement", "every death teaches").
Every decision is checked against the pillars: if it doesn't serve them, it's probably out of scope.
The number-one cause of indie games never finished. Ideas multiply, time doesn't.
Mantra: cut features, start from an MVP, "finish the game". Better small and complete than huge and abandoned.
Blood, Sweat, and Pixels (Jason Schreier) for the reality of development.
Find the fun as early as possible with rough, throwaway prototypes. No art: boxes and placeholders.
Prototype the riskiest/most uncertain pieces first: if the core isn't fun, no graphics will save it.
A small but complete and polished slice at final quality (e.g. a real, "shippable" level).
It proves the vision to yourself, the team, publishers and wishlists. It's your best calling card.
For a solo/small team: lean, living documents. A one-page with pitch, pillars, loop, look is often better than 200 pages no one reads.
The document is there to think and align, not to impress.
Test early and often. Observe in silence, don't guide, don't explain the controls.
The player is always right about what they feel; almost never about why or about the solution. You interpret the data and iterate.
Design → prototype → playtest → iterate → polish → ship.
Polish (juice, audio, transitions) comes last, when the design is solid: polishing something broken is wasted time.
Breaking the project into manageable goals.
An explicit cut list is the antidote to scope creep.
Keeping the project healthy and shippable.
Knowing how to say "it's done" is a production skill.
Better small and finished than huge and abandoned.
The fastest way to grow: tight constraints, a deadline, a complete game in hand.
Finishing 3 jams teaches more than 30 projects never closed.
Lean documents that actually get updated.
Reference: Stone Librande's "one-page design" (GDC).
Checklists so you don't forget the essentials:
Accessibility and Steam-page checklists have established public standards.
Build your own reference library.
Study actively: for every choice, ask yourself "why?".
Typical 2D indie tools, by domain:
UX guides attention: what matters must stand out.
Rule: the eye must find critical info without searching for it.
The HUD communicates state in real time, without noise.
Avoid the "noisy UI": every element must earn its place.
The flows outside the game matter as much as those inside it.
A good menu is navigated with your thumb without thinking.
Dense interfaces that must be made comprehensible.
A readable map is half of wayfinding.
Teach at the right moment, with minimal text.
The best tutorial is the level itself (see "Teaching through design").
A useful taxonomy for choosing the right immersion/clarity trade-off.
Diegetic = immersion; non-diegetic = clarity. Often a mix.
Mobile isn't "a smaller PC": the usage context, input and attention all change.
Small-screen readability: few elements, large and high-contrast.
Functional roles that force different behaviors on the player:
Each archetype is a different "question" posed to the player.
An enemy isn't just a sack of HP: it's a problem to solve.
Combining archetypes creates more interesting "compound questions".
What makes a fight feel fair.
The more lethal the attack, the longer and clearer the warning must be.
Most enemy AI is a readable state machine.
patrol → chase → attack → retreat → stunned"Understandable" AI > "smart but opaque" AI.
The "mix" and timing make the encounter, more than any single enemy.
The boss is the final exam of what the player has learned.
A boss that drags on tires the player: tend to the pace, not just the difficulty.
Two complementary lenses on real players.
Together they answer "what happens" and "why it happens".
Events that reveal the real experience (with consent — see Legal).
Track with a purpose: every event must answer a question.
Visualizing the data to find the problems.
A spike in drop-off = a spike in difficulty or confusion.
Using the numbers to tune, without chasing them blindly.
Data guides, design decides.
A poorly run test misleads more than it informs.
Stay quiet and observe: behavior > opinions.
Ask well, then rank what to fix.
The player is right about the problem, rarely about the solution.
A stuck state (softlock) frustrates more than a defeat: prevent it by design.
For puzzles: always guarantee at least one reachable solution.
Why someone should notice your game.
If you can't sum it up in one line, it's hard to sell.
Know your audience and competition before building.
Position yourself near your references, but with a clear difference.
The storefront that converts the curious into wishlists.
The capsule is your "manifesto" in a few pixels: tend to it.
The two assets that show the game in action.
No long logos at the start: show the game right away.
Indie marketing is building an audience during development.
Start early: wishlists accumulate over time, not a week before launch.
How much and how to sell.
Launch is the beginning, not the end.
Positive Steam reviews feed visibility over time.
Free-to-play models live on micro purchase-decisions: the line between design and manipulation is thin.
Monetize value, not frustration: transparency and respect pay off long-term.
Building a community is only half the job: the other half is managing it over time, crises included.
A promised-but-unkept update costs more trust than a missing feature.
Sound is half the feedback: you often "hear" before you "see".
Coordinate sound, animation and VFX: coherence sells the impact.
Music that reacts to the game state.
Tools: FMOD/Wwise for dynamic transitions and layering.
Every sound communicates something specific.
A clear "error" sound prevents frustration better than a popup.
Sound anticipates and builds emotion.
In horror, well-judged silence scares more than a bang.
Keeping sound from tiring or annoying.
Listen to a long session: whatever tires you out needs smoothing.
Every third-party asset has a license: read it before using it.
Keep proof of licensing. When in doubt, check the source or consult an expert.
Two different protections, both to be respected.
This is not legal advice: for concrete cases, see a lawyer.
Free code and generated content: handy but with rules.
Document the origin and license of every dependency and asset.
If you collect data, you have responsibilities toward players.
Regulations (e.g. GDPR) vary by region: check the applicable requirements.
To publish, you must respect ratings and store rules.
Plan the rating early: it affects marketing and availability.
Write from the start to be translatable without redoing everything.
Design the UI for +30-40% text length.
The technical pitfalls that break translations.
"You have {n} apple/s" doesn't work everywhere: hand whole sentences to the translator.
Translating the words ≠ adapting the experience.
Give translators context: without it, even simple lines go wrong.
The final steps that make the perceived difference.
Subtitles are also accessibility: see "Subtitles & CC" in UX.
Separate the numbers from the code to iterate fast.
In Godot: custom Resources / @export for designer tuning.
Structure the project for reuse and clarity.
Well-named collision layers prevent "ghost" bugs.
The patterns that structure behavior and reactivity.
Events > scattered checks: they reduce dependencies and bugs.
Data tables that feed the game systems.
Keep them in external data so the designer tunes them, not the programmer.
Technical hygiene that saves hours.
Boring conventions today = instant searches tomorrow.
Building internal tools accelerates iteration.
Every hour spent on tooling pays back in dozens of iterations.
Every platform has technical requirements you must pass to publish.
Plan certification early: cert failures delay the launch.
Mistakes that bloat the game without adding depth.
Antidote: a few deep systems (see "Depth vs complexity") and a cut list.
When the player's decisions lose meaning.
Antidote: real trade-offs (see "Meaningful decisions").
The mistakes that make a game feel unfair.
Antidote: fairness, telegraphing and a fast retry.
When growth and rewards stop motivating.
Antidote: meaningful rewards and a carefully tended progression curve.
Teaching and showing badly.
Antidote: teaching through design and a clear visual hierarchy.
Mistakes of pacing and coherence at a large scale.
Antidote: rewarding backtracking and harmony between story and mechanics.
Teaching without text. The level is an invisible tutorial.
Lesson: level design can teach better than any pop-up.
Jump feel, assist mode and precision platforming.
Lesson: hard and accessible can coexist.
Readable procedural generation.
Lesson: procgen works if it stays readable and fair.
Core loop, reward pacing and readability in chaos.
Lesson: a simple loop + perfect reward pacing creates healthy addiction.
Map, gating, atmosphere and backtracking.
Lesson: a well-made map is content in itself.
Perfect information and readable tactics.
Lesson: removing chance can make tactics deeper.
Systemic narrative, roguelite pacing and reactive dialogue.
Lesson: a roguelite can tell a story by folding death into the loop.
Emergent synergies, readability and risk/reward.
Lesson: starting from familiar rules frees up room for depth.
Combat, builds, pace and run progression.
Lesson: combat feel + build variety = very high replayability.
Puzzle grammar and progressive teaching.
Lesson: teach systems like a language, one concept at a time.
Deckbuilding, risk and synergies.
Lesson: it defined the modern roguelite deckbuilder.
Routine, soft goals and motivation to return.
Lesson: healthy retention comes from soft purposes and satisfying closures.
Mechanic, ethics and rising pressure.
Lesson: a single mechanic can carry a powerful theme.
Subverting the rules and the relationship with the player.
Lesson: breaking a known convention creates unforgettable moments.
The MDA separates three levels that often get confused. Mechanics are the rules and formal data (what exists in the system); Dynamics are the behaviors that emerge while playing; Aesthetics are the emotions that result. The designer works left to right (builds rules hoping for certain emotions), but the player lives it right to left (feels first, then discovers why).
When a player says "it's not fun", the problem is almost always in the dynamics. Trace the chain back: what behavior did you want? Which rule produces or prevents it? Changing a number (a mechanic) can fix an emotion (aesthetic) without touching the story.
Deep-dive: the original paper "MDA: A Formal Approach to Game Design" (Hunicke, LeBlanc, Zubek) and Jesse Schell's "lenses".
The core loop is the thing the player does most often. If it's boring, no amount of content or story saves it. Loops are nested: the micro one (press a button, see an effect) sits inside the meso one (clear a room) which sits inside the macro one (unlock, upgrade, start over).
move → dodge → shoot (Vampire Survivors), rotate → fit → clear line (Tetris)Deep-dive: "30 seconds of fun" (Bungie) and Daniel Cook's article "Loops and Arcs".
The 3 Cs are what the player touches on every single frame, so nail them before everything else.
A platformer with mediocre levels but perfect 3 Cs is playable; the reverse almost never. That's why you prototype the 3 Cs first, in an empty grey room, until moving is already pleasant on its own.
Deep-dive: the Mario and Celeste controllers are the classic "feel" case studies.
Designing around verbs (actions) instead of "features" keeps the design focused. A strong verb is deep (generates many situations) and combinable with the others.
Better a few verbs explored deeply than twenty shallow ones. Mario's jump is a single verb, yet it interacts with enemies, platforms, power-ups and bounce-enemies to generate endless situations. Portal has essentially one verb (open a portal) and builds an entire game on it.
Deep-dive: the concept of "verb-first design"; GMTK analyses of movesets.
Affordance is what an object lets you do; the signifier is the signal that communicates it. In games what matters most is perceived affordance: if a ledge looks climbable but isn't, you've created a false affordance — the number-one source of frustration.
Deep-dive: Don Norman, "The Design of Everyday Things" (ch. on affordance and signifiers).
Without feedback the game feels broken even when it works. Every input should trigger an action → animation → effect chain across multiple channels: visual (flash, particles, screen shake), audio (a sound per event) and, where possible, haptic (vibration).
It's the warning that makes a challenge fair: the enemy's wind-up, the flash before a hit, the sound preceding an event. The more dangerous the attack, the longer and more readable the warning must be. In bullet hell, telegraph readability literally is the game.
Deep-dive: the talk "The Art of Screenshake" (Jan Willem Nijman, Vlambeer).
Sid Meier defines a good game as "a series of interesting decisions". A choice is interesting when no option is obviously the best in every situation.
A meaningful choice has information + real consequence + trade-off (you give something up).
Deep-dive: Sid Meier's GDC talk "Interesting Decisions".
Emergent design bets on a few rules that interact, generating situations the designer didn't plan one by one. It's efficient: little authored content, a huge "possibility space".
Scripted design gives total directorial control (cutscenes, set-pieces) but is costly and doesn't repeat. Almost every game mixes the two: choose where you want surprise (emergent) and where you want precision (scripted).
Deep-dive: the design of immersive sims and "systemic games".
Flow is the band where challenge grows together with skill: above it is anxiety, below it is boredom. Since the player keeps improving, difficulty must rise, but not linearly — better oscillations (peaks and breathers) that follow the learning curve.
Deep-dive: Mihály Csíkszentmihályi, "Flow"; the pacing chapters in level-design books.
Marc LeBlanc's taxonomy helps you stop saying the vague "fun" and ask which pleasure you offer:
Almost no game offers them all: the best pick two or three and serve them well.
Deep-dive: "8 Kinds of Fun" (LeBlanc), part of the MDA framework.
Micro-definitions with an example:
Deep-dive: glossaries on gamedeveloper.com and competitive wikis.
Micro-definitions with an example:
Deep-dive: see the "Game economy" and "Diegetic vs non-diegetic" cards.
The formal elements are the components that, put together, turn an activity into a game. The most-used model is Tracy Fullerton's: players, objectives, procedures (the allowed actions), rules, resources, conflict, boundaries and outcome.
→ Deep-dive: T. Fullerton, Game Design Workshop; K. Salen & E. Zimmerman, Rules of Play.
Rules define the space of the possible; objectives give direction; constraints make the "how" interesting. Often a single well-chosen constraint generates more gameplay than a new rule.
→ Deep-dive: the rules/objectives/constraints triplet is central to J. Schell, The Art of Game Design.
Win and lose conditions define when and why a match ends. Game states (menu, play, pause, game over, victory) are the experience's high-level state machine.
→ Deep-dive: compare the death/retry loops of Celeste and of roguelites.
The possibility space is everything the player can do: rules define and limit it. The core fantasy is the central fantasy the game promises to deliver ("you're a silent ninja", "build and run an empire").
→ Deep-dive: the "possibility space" concept is discussed by Will Wright and in many GDC talks.
Tell apart the player's skill (reflexes, reading, decisions) from the avatar's (stats, gear). The skill floor is how easy it is to start playing decently; the skill ceiling is how high mastery can go; the mastery curve is the path between the two.
→ Deep-dive: the "mastery curve" is a recurring theme in R. Koster, A Theory of Fun.
Agency is only real if the player understands what to do and what will happen. You need clarity of objectives (I always know the next step) and readability of consequences (I grasp a choice's effect before making it).
→ Deep-dive: links to "Agency & meaningful choice" and "Meaningful decisions".
The magic circle (Huizinga; taken up by Salen & Zimmerman in "Rules of Play") is the space — physical or purely mental — where the game takes place: crossing its boundary means accepting rules different from those of real life.
→ Deep-dive: J. Huizinga, "Homo Ludens"; K. Salen & E. Zimmerman, "Rules of Play".
Nicole Lazzaro's 4 Keys to Fun come from watching the emotions on players' faces. They complement LeBlanc's 8 kinds and help you ask which emotion you're aiming for.
→ Deep-dive: Nicole Lazzaro, "The 4 Keys to Fun"; compare with "The 8 kinds of fun".
Strong design starts from one central mechanic and builds everything else around it. Secondary mechanics must serve the core, not compete with it for attention.
Mentally remove a mechanic: if the game is still "the same", it was secondary; if it collapses, it was the core. In Celeste the core is movement (dash included); everything — enemies, hazards, levels — exists to create movement situations. A common indie mistake is stacking mechanics to "add value", ending up diluting the experience.
Deep-dive: "elegance" and "depth vs complexity" in "Characteristics of Games" (Elias, Garfield, Gutschera).
Tying higher rewards to higher risks creates tension and gives the player a lever over how much to dare. It's one of the most reliable emotional engines in game design.
The variant where you keep accumulating until you lose it all: each step raises the stakes and the fear. You find it in roguelites (descend one more floor), in loot slot machines, in run "greed". Design rule: make the risk visible and always leave a voluntary exit, so the choice stays the player's.
Deep-dive: "press your luck" mechanics in board games (e.g. Can't Stop) applied to video games.
These assists correct the gap between what the player intended to do and the raw input, making the controls feel fair even when they aren't perfect. They're mostly invisible.
coyote time — a ~3–6 frame window in which you can still jump after leaving the edgejump buffering — if you press jump just before landing, it fires the moment you touch groundvariable jump height — how long you hold = how high you jumpapex modifier — slight slowdown/extra control at the peak of the jumpcorner correction — "nudges" you past a corner if you barely clip it at the ceilingOn their own they look like details; together they're the difference between "slippery controls" and "controls that read your mind".
Deep-dive: the Celeste and Super Mario GDC routines; look for the diagrams on coyote time and jump buffer.
The "feel" of combat comes from how collisions and reactions are timed, more than from damage numbers.
Deep-dive: frame-data breakdowns of fighting games; the combat of Hades and Hollow Knight.
"Juice" is the set of effects that, with the rules unchanged, makes actions pleasant to perform. It's disproportionate: small tweaks radically change perception.
Be careful not to overdo it: too much shake or flash hurts readability and accessibility. Add juice during polish, on top of an already solid design.
Deep-dive: Steve Swink "Game Feel"; the "Juice it or lose it" talk (Grapefrukt); "The Art of Screenshake".
The camera decides what the player sees and when: it's a "silent designer" that can make a game readable or nauseating.
In 2D pixel, remember pixel-perfect: round the camera position or you'll get jitter (see "Pixel-perfect & scaling").
Deep-dive: "50 Game Camera Mistakes" (GDC); the camera system of Celeste/Super Mario World.
A resource becomes interesting only when it's scarce and when spending it involves a sacrifice. Health, ammo, stamina, currency, energy: each one poses a question to the player.
A resource without tension (always abundant) is just a number going up: either make it scarce, or remove it.
Deep-dive: see "Game economy"; resource theory in board games.
Procgen creates content through rules + randomness: great for replayability and for multiplying content cheaply. Use a seed so the same run is reproducible (useful for debugging and for sharing "seeds").
Pure randomness gets boring fast. The best games use a hybrid: hand-designed rooms, pieces or rules, assembled procedurally (Spelunky, Dead Cells). Add constraints ("constraint-based") to guarantee that levels are always completable and sensible.
Deep-dive: GDC talk on Spelunky's generation (Derek Yu); wave function collapse; "procedural generation" in PCG.
Input design is the first layer of "feel": how the player's intention becomes action on screen. It covers mapping (which buttons for which actions), latency, buffering and stick deadzones.
→ Deep-dive: S. Swink, Game Feel; see also "Movement tech" for coyote time and jump buffer.
Every device has a different "grammar". Design for the primary device and adapt the others, instead of a compromise that satisfies no one.
→ Deep-dive: supporting a few inputs well is worth more than supporting many badly.
Cooldowns, time windows and status effects are tools for giving rhythm and depth to actions, turning "pressing a button" into a decision.
→ Deep-dive: contextual interactions (an action that changes with context) multiply the use of few buttons.
Collectibles are immediate rewards and pacing levers. A good pickup is clear and attractive; a good power-up changes how you play, not just the numbers.
→ Deep-dive: connect to "Resources" and "Risk & reward".
The mechanical heart of stealth is enemy information: what it knows, what it sees, how much it suspects. The player plays with this information.
→ Deep-dive: Mark of the Ninja is the reference on 2D stealth readability.
When physics simulation is the gameplay (not just decoration), weight, inertia and forces become the decision space.
→ Deep-dive: Angry Birds, World of Goo, Human: Fall Flat.
Where the score is the real goal (arcade, shmup, character-action, rhythm), the scoring system is the game design: it decides what to reward, and therefore how the game is played.
→ Deep-dive: the scoring of Ikaruga; the "style meter" of Devil May Cry; see "Risk / reward".
In turn-based games (tactics, traditional roguelike, 4X, deckbuilder) the action economy is the heart of the decisions: the value of each move depends on how many you have and when it's your turn.
→ Deep-dive: action economy in tactical RPGs; the "perfect information" of Into the Breach; see "Balancing".
Movement abilities are the traversal verbs that give identity to platformers, metroidvanias and action games. They're different from the forgiveness "assists" (coyote time, buffer): here we mean the toolkit you move with.
Every ability is also a key (gating): unlocking it opens up new areas and situations.
→ Deep-dive: the movesets of Celeste and Hollow Knight; see "Movement tech" and "Gating · Lock & Key".
The health and damage model is a design choice, not a detail: it defines how "lethal" the game is and how the player weighs risk.
→ Deep-dive: Zelda's "hearts"; Halo's regenerating shields; see "Combat fundamentals".
The aiming layer mediates between intention and hit. Tuning it well is crucial for the feel on a controller and for accessibility, without slipping into "the game plays itself".
→ Deep-dive: the Z-targeting of Ocarina of Time; aim assist in console shooters; see "Input design".
A good level teaches without text tutorials, in four beats (the "kishōtenketsu" structure made famous by analysis of Mario's levels):
Classic example: Super Mario Bros. 1-1 teaches jumping, enemies and power-ups without a single word. If you need a text box to explain, the level often isn't doing its job.
Deep-dive: the video "Super Mario 3D World’s 4 Step Level Design" (GMTK); Anna Anthropy & Naomi Clark, "A Game Design Vocabulary".
Pacing is the management of tension and breathing room over time. Difficulty and intensity don't rise in a straight line: they trace a sawtooth profile, with peaks followed by calm moments that let the player digest.
Deep-dive: the "beat charts" and intensity graphs in level-design books (e.g. "An Architectural Approach to Level Design", Totten).
The critical path is the readable route to the end; optional branches (secrets, shortcuts, challenges) add depth without hindering those who just want to move forward.
Key balance: those who run straight have fun, those who poke around are rewarded — without either feeling penalized.
Deep-dive: "golden path" and "critical path" in AAA level-design documentation.
Gating controls the pace of progression: it blocks access to an area until the player has the right key.
Well-done backtracking makes the map "grow": you return to known zones with new powers and see them in a different light (Metroid, Hollow Knight). Lazy backtracking = empty walks; good backtracking = new possibilities in old areas.
Deep-dive: "lock and key" design; the map design of Super Metroid and Hollow Knight.
Players go where their gaze leads them. You can guide them without arrows using composition: light, color, contrast, leading lines (corridors, beams, rays) that point where you want.
In 2D the background matters enormously: silhouettes and colors in the background orient the player without invading the foreground.
Deep-dive: "environmental wayfinding"; the level art of Ori and Hollow Knight.
Build the level's playable shape first with grey volumes (greybox/whitebox), no art. That way you test and change the layout while it's still cheap to change.
Applying art early makes it painful to move a platform or redraw a room: you get "attached" and the cost of change explodes. Mantra: layout → test → iteration → art. Art is the last layer, not the first.
Deep-dive: blockout workflow; planning with beat charts before construction.
The distance between checkpoints defines how "punishing" a challenge is. Repeating 5 seconds after a mistake motivates ("let me try again right now"); repeating 5 minutes makes players quit.
Distinguish "good" difficulty (I need to improve) from "bad" difficulty (I have to redo a boring stretch).
Deep-dive: the respawn design of Celeste and Super Meat Boy.
The player learns to "read" your world if every concept always looks the same. Consistency means trust: I can trust what I see.
If spikes are deadly in one place and harmless in another, you've broken the pact: the player won't know what to trust anymore and every death will feel unfair. Establish the "palette of meanings" and respect it throughout the game.
Deep-dive: "visual language" and "readability" in level/UI design.
Designing an encounter means designing the space, not just the enemies. The arena determines the rhythm, tension and readability of combat.
→ Deep-dive: connect to "Pacing" and to the Enemy & Encounter category.
In a platformer, space is measured in the character's abilities: first define the movement metrics, then build levels on that grid.
→ Deep-dive: build a "metrics test room" and calibrate every gap before drawing levels.
Linking the map back to itself makes it "breathe" and reduces the frustration of retreading old ground.
→ Deep-dive: metroidvanias (Hollow Knight) are the main case study.
Reward curiosity without penalizing those who go straight: secrets are optional but gratifying.
→ Deep-dive: a found secret should give the right little "dopamine hit".
Genre defined by movement through space: jumping, running, dodging obstacles. Quality lies almost entirely in the "feel" of the controls (see "Platformer movement tech").
It's the "school" genre for learning game feel: easy to prototype, brutal to polish.
Deep-dive: analysis of Celeste's controller; "Why Does Celeste Feel So Good to Play?" (GMTK).
A portmanteau of Metroid + Castlevania: a large interconnected map explored non-linearly, where new abilities unlock previously inaccessible areas (ability-gating) and invite backtracking.
Examples: Hollow Knight, Ori, Blasphemous, Axiom Verge, Guacamelee!. "Soulsvania" variant: Nine Sols, Salt and Sanctuary.
Deep-dive: the map design of Super Metroid and Hollow Knight; GMTK's "Boss Keys" series.
You advance sideways (or on a 2.5D plane) facing waves of enemies bare-handed or with weapons. The heart is crowd control and combo rhythm.
Often thrives on local co-op. Examples: Streets of Rage 4, Scott Pilgrim, River City Girls, Castle Crashers.
Deep-dive: the combat design of Streets of Rage 4; the history of the arcade genre.
1v1 combat (or a multiplayer "platform fighter") based on spacing, reading the opponent and knowledge of frame data (how many frames each move lasts, which are "advantageous"). It's a genre of extremely high technical depth.
For an indie it's demanding (rollback netcode, balancing, roster). 2D indie examples: Skullgirls, Rivals of Aether, Them's Fightin' Herds.
Deep-dive: the "Footsies Handbook"; documentation on rollback netcode (GGPO).
Acrobatic, deep combat where style is rewarded: long combos, cancels, managing multiple enemies, "rank" evaluation (S, SS…). Different from loot ARPGs: here execution matters, not gear.
3D: Devil May Cry, Bayonetta, Ninja Gaiden. 2D/iso: Hades, Hyper Light Drifter.
Deep-dive: the combat breakdowns of Devil May Cry and Hades.
The player avoids direct conflict: observes patrols, manages line of sight and alert levels, acts at the right moments. Tension comes from information: what the enemy knows, suspects or ignores.
2D: Mark of the Ninja (the reference for readability), Gunpoint. 3D: Metal Gear, Thief, Dishonored.
Deep-dive: GDC talk on Mark of the Ninja (Klei) and "stealth readability".
Auto-scrolling where you dodge bullets and shoot. In the "bullet hell"/danmaku subgenres the screen fills with patterns that are genuine choreographies to learn.
Examples: Ikaruga, DoDonPachi, Touhou, ZeroRanger, Jamestown.
Deep-dive: the "scoring system" as the heart of shmup design; analysis of Ikaruga.
You move and aim independently (two sticks, or WASD + mouse). This separates locomotion and aim, letting you shoot in one direction while moving in another — the basis of a dodge-and-hit dance.
Examples: Enter the Gungeon, Nuclear Throne, Geometry Wars, Hotline Miami (lean top-down).
Deep-dive: the game feel of Nuclear Throne (Vlambeer) and the enemy design of Enter the Gungeon.
Methodical, deliberate and punishing combat: stamina management, attacks that "commit" you, lethal enemies, bonfires/checkpoints that restore resources but respawn enemies. The philosophy is "die, learn, retry".
2D/indie: Salt and Sanctuary, Blasphemous, Nine Sols, Death's Gambit. Metroidvania-souls: Hollow Knight.
Deep-dive: FromSoftware's design; "What Makes a Good Soulslike".
First-person action. Under the "FPS" umbrella live opposite philosophies: from the frantic movement of the classics to the tactical pace of modern military shooters.
For indies the boomer shooter is the liveliest niche: small teams, retro aesthetics, dense gunplay.
Deep-dive: the movement of DOOM Eternal; the history of arena shooters.
Multiplayer genres born in the 2010s. Battle royale: many players, one map, a shrinking circle, the last one wins. Extraction shooter: you go in, gather loot and must extract alive — dying means losing everything.
Examples: PUBG, Fortnite, Apex Legends; Escape from Tarkov, Hunt: Showdown.
Deep-dive: the evolution of BR from ArmA/DayZ mods; risk/reward in extraction games.
RPG of the Japanese tradition: turn-based (or ATB) combat, a party of distinctive characters and a strong linear story. The pleasure lies in growth, team-building and narrative drama.
Classics: Final Fantasy, Chrono Trigger, Dragon Quest. Indie pixel: Sea of Stars, Chained Echoes, Cosmic Star Heroine.
Deep-dive: the battle design of Chrono Trigger; the HD-2D style of Octopath Traveler.
RPG of the Western tradition, centered on choices, systems and a reactive world. Build freedom and the consequence of decisions matter more than narrative linearity.
Classics: Baldur's Gate, Planescape: Torment, Fallout. Modern: Baldur's Gate 3, Divinity: Original Sin 2, Disco Elysium.
Deep-dive: the reactive writing of Disco Elysium; "choice and consequence".
RPG with real-time combat, where the engine is the loop of loot and growth: kill enemies → collect better gear → get stronger → take on harder challenges.
Looters: Diablo, Path of Exile, Grim Dawn, Titan Quest. Action open-world: The Witcher 3, Nioh. 2D/iso indie: Hades, CrossCode, Children of Morta.
Deep-dive: "the loot loop" and the item economy in Path of Exile.
Tactical grid battles: you move units in turns, minding positioning, terrain, range and action order. Often there's permadeath, which gives weight to every move.
Classics: Final Fantasy Tactics, Tactics Ogre, Fire Emblem. Modern/indie: Into the Breach (a "perfect information" tactics game), Wargroove, Triangle Strategy, Fae Tactics.
Deep-dive: the "puzzle" design of Into the Breach (Subset Games).
Dungeon exploration, often in first-person on a grid ("blobber"), with mapping, encounters and careful step-by-step management of party and resources.
Blobbers: Etrian Odyssey, Eye of the Beholder, Legend of Grimrock. (Diablo is a "dungeon crawl" but is itself an ARPG.)
Deep-dive: the "blobber" tradition and the design of Etrian Odyssey.
You capture, raise and evolve creatures that fight for you. Three pleasures in one: collection, team-building and battles (often turn-based with a type system).
Reference: Pokémon. Indie: Monster Sanctuary (2D), Cassette Beasts, Coromon, Temtem, Ooblets.
Deep-dive: the "type chart" as a balancing system; the design of collecting.
The "pure" sense: turn-based, on a grid, ASCII/tile graphics, total permadeath and no meta-progression (you really start from scratch). The "Berlin Interpretation" codifies these traits.
Historic: Rogue, NetHack, ADOM. Modern: Dungeon Crawl Stone Soup, Caves of Qud, Cogmind, Tangledeep.
Deep-dive: the "Berlin Interpretation" of the roguelike; the emergent design of NetHack.
The "modern, accessible" version: procedural, lethal runs, but with meta-progression that persists between deaths (unlocks, upgrades, new options). The motto is "every death makes you a bit stronger or a bit better".
Examples: Hades, Dead Cells, Enter the Gungeon, Rogue Legacy, Spelunky, The Binding of Isaac, Risk of Rain 2, FTL.
Deep-dive: the "narrative roguelite" of Hades (Supergiant); the run-flow of Dead Cells.
A subgenre that exploded in 2022 with Vampire Survivors: ever-denser hordes of enemies, automatic attacks, and at each level-up you pick one upgrade among a few. The goal is to survive N minutes while your build "explodes" with power.
Examples: Vampire Survivors, Brotato, Halls of Torment, 20 Minutes Till Dawn, Death Must Die.
Deep-dive: the postmortem of Vampire Survivors; the "power fantasy" of the exponential curve.
You build and refine a deck over the course of play, seeking synergies between cards. The fun is discovering combos and optimizing the "machine" you build.
Design key: a few cards with deep interactions > many flat cards.
Deep-dive: the design of Slay the Spire (Mega Crit); "deckbuilding" in board games (Dominion).
You gather resources, build a base, produce and command armies — all in real time. The challenge is splitting attention between macro (economy, expansion) and micro (controlling individual units in battle) under constant pressure.
Classics: StarCraft, Age of Empires, Command & Conquer, Warcraft III. Indie: They Are Billions, Tooth and Tail, Bad North.
Deep-dive: the asymmetric balancing of StarCraft; "macro vs micro".
Strategy without haste: you plan in turns. 4X (eXplore, eXpand, eXploit, eXterminate) has you guide a civilization from birth to dominance, with the famous "one more turn" addiction.
Design: meaningful decisions every turn and clear feedback on long-term cause/effect.
Deep-dive: "one more turn" design; the systems of Crusader Kings (Paradox).
You defend one or more paths by placing turrets that automatically attack waves of enemies. It's spatial and economic strategy: where you build, what you upgrade, how you spend resources between waves.
Examples: Kingdom Rush, Bloons TD, Defense Grid; hybrids like Plants vs. Zombies and Orcs Must Die.
Deep-dive: the balancing of waves; the history of the genre (from Warcraft III mods).
Competitive genres born from Warcraft/Dota mods.
Both are heavily multiplayer and meta-driven: hard to sustain for a solo dev.
Deep-dive: the draft economy in auto-battlers; lane design in MOBAs.
Simulates daily life: you farm, raise animals, build relationships with NPCs, mark days and seasons. A relaxed rhythm and "soft" progression; often falls under cozy.
References: Stardew Valley, Story of Seasons (Harvest Moon), Animal Crossing. Indie: My Time at Portia, Fields of Mistria, Sun Haven.
Deep-dive: the solo-dev success of Stardew Valley (ConcernedApe).
You manage a colony/base and many interconnected variables (food, mood, temperature, logistics). The content isn't scripted: it's the emergent chaos of the systems that generates crises and unrepeatable stories.
References: Dwarf Fortress, RimWorld, Oxygen Not Included; survival management: Frostpunk, Banished; logistics: Factorio, Satisfactory.
Deep-dive: RimWorld's "storyteller"; the emergent stories of Dwarf Fortress.
You build and expand cities, parks or businesses, optimizing flows (traffic, people, money). The heart is economic balancing and the efficiency of the systems you design.
City builders: SimCity, Cities: Skylines, Townscaper, Against the Storm. Tycoon: RollerCoaster Tycoon, Two Point Hospital, Game Dev Tycoon.
Deep-dive: the traffic systems of Cities: Skylines; the roguelite-builder Against the Storm.
More a design philosophy than an aesthetic: you build deep, consistent systems that combine, and let the player solve every situation their own way (stealth, combat, hacking, bypassing).
Progenitors: System Shock, Deus Ex, Thief. Modern: Dishonored, Prey (2017). (In 2D, "systemic design" inherits much of this.)
Deep-dive: the immersive-sim design talks from Arkane and Looking Glass.
You gather resources, craft tools, build a shelter and survive hunger, enemies and the environment. Often open-world, with a day/night cycle and progression driven by recipes.
explore → gather → craft → build → survive at rising difficulty2D: Terraria, Core Keeper, Necesse. 3D: Minecraft, Don't Starve, Subnautica, Valheim.
Deep-dive: "progression gating" via crafting; the survival loop of Don't Starve.
You manipulate shapes, blocks or physics. Very simple rules, combinatorial depth: easy to understand, hard to master.
Design: clarity of the rules is everything; depth comes from interactions, not from adding exceptions.
Deep-dive: "flow" theory applied to Tetris; the design of physics puzzles.
Puzzles of pure reasoning, no rush: the goal is the "a-ha" moment, the insight that solves it, not random attempts.
Golden rule: a good puzzle has one clear insight; if it can be brute-forced, it's poorly designed.
Deep-dive: the "non-verbal" design of The Witness (Jonathan Blow).
You solve by building machines or "programs" that perform the task; often there's no single solution, and the challenge becomes optimization (fewer steps, lower cost, more speed).
Zachlikes: Opus Magnum, SpaceChem, Shenzhen I/O, TIS-100. Factory: Factorio, Shapez, Infinifactory.
Deep-dive: the design of Zachtronics games; the engagement loop of Factorio.
You explore static scenes, collect items into the inventory, combine them and solve puzzles to advance the story. Writing, humor and atmosphere are the real content.
Classics: Monkey Island, Day of the Tentacle, Grim Fandango. Indie: Machinarium, Thimbleweed Park, Kentucky Route Zero, Unavowed.
Deep-dive: LucasArts puzzle design; the "puzzle dependency chart".
A story told mostly through text (and static images), with choices that branch the plot. Minimal systemic gameplay, or hybridized with other genres.
VN: Ace Attorney, Doki Doki Literature Club, Danganronpa, Steins;Gate. Indie pixel: VA-11 Hall-A, Slay the Princess. IF: Zork, 80 Days.
Deep-dive: Ren'Py and Twine; branching narrative structures.
You explore a place and reconstruct a story, with little or no mechanical challenge. It's environmental storytelling taken to the extreme: the place is the narrative.
References: Gone Home, Firewatch, Dear Esther, What Remains of Edith Finch. Short/cozy: A Short Hike, Lake.
Deep-dive: the level/narrative design of What Remains of Edith Finch.
Scarce resources, a vulnerable character, an oppressive atmosphere: fear comes from helplessness + scarcity and the tension of the unknown, not from jump scares alone.
3D: Resident Evil, Silent Hill, Amnesia. 2D/pixel indie: Faith, Lone Survivor, Detention, Signalis.
Deep-dive: "resource scarcity" in horror; the 2D atmosphere of Faith and Signalis.
Input must be performed in time with the music: the score rewards timing precision. The genre's strength is its fusion with others (roguelike, shooter, platformer).
Classics: Guitar Hero, DDR, Beat Saber. Hybrids: Crypt of the NecroDancer (rhythm + roguelike), Rhythm Doctor. Indie: Friday Night Funkin', Thumper, Sayonara Wild Hearts.
Deep-dive: the hybrid design of Crypt of the NecroDancer; latency handling in rhythm games.
Simulation or arcade of sports and driving. The spectrum runs from deep realism (physics, rules) to arcade immediacy (fun-first, exaggerated physics).
For small teams arcade is almost always the right choice. Indie/pixel: Golf Story, Sportsfriends.
Deep-dive: the game feel of Rocket League; "easy to learn, hard to master" design.
Progression is automatic and tends toward the exponential: you optimize systems, unlock multipliers and "let it run", sometimes with voluntary resets ("prestige") that accelerate later growth.
Examples: Cookie Clicker, Universal Paperclips, NGU Idle, Melvor Idle.
Deep-dive: "Universal Paperclips" as a design case; the math of incremental curves.
Few buttons, lots of chaos: the fun comes from interaction between people, on the couch or online. Scene readability and control immediacy are top priorities.
Chaotic co-op: Overcooked, Moving Out, PlateUp!. Party: Mario Party, Jackbox, Pummel Party. Tight co-op: Pico Park, It Takes Two.
Deep-dive: the design of "fun" frustration in Overcooked.
A category defined by tone more than mechanics: no pressure, no punishing failure. It offers comfort, creativity and calm. Growing fast and strongly indie.
References: Stardew Valley, Animal Crossing, Spiritfarer, Unpacking, A Short Hike, Coffee Talk, Dorfromantik.
Deep-dive: the "Cozy Game" as a movement; the emotional design of A Short Hike.
Genre isn't a cage: it's a language. It sets the player's expectations (a metroidvania "promises" backtracking) and gives you tested conventions to start from.
Knowing genres also helps you communicate your game quickly ("it's a roguelite deckbuilder") to players and publishers.
Deep-dive: genre taxonomies on stores (Steam tags) and their impact on discoverability.
The design frontier comes from crossovers: take one genre's loop and graft it onto another. For an indie, the unexpected crossover is often the winning idea (more memorable and easier to communicate than "yet another X").
Deep-dive: the postmortems of "genre mashups" that created new niches.
Every action genre carries implicit promises and conventions the audience takes for granted. Knowing them lets you fulfill them — or break one on purpose, knowingly.
→ Deep-dive: respect the basic promises, then differentiate on one precise axis.
Roguelites and deckbuilders share the DNA of variety between runs and the emergent build.
→ Deep-dive: Slay the Spire (deckbuilder) and Hades (roguelite) as models.
Puzzle and tactical are genres of pure intellect: the challenge lies in thinking, not reflexes, and they require total readability.
→ Deep-dive: connect to "Depth vs complexity" and "Teaching through design" (Portal).
Three tones, three different pacts with the player. Getting the tone wrong (a "punishing" cozy game) betrays expectations and pushes away the target audience.
→ Deep-dive: Stardew Valley (cozy), RimWorld (management), Resident Evil (survival).
For an indie, genre is first of all a decision about scope and market. Some genres are "friends" of the small team, others require enormous resources.
→ Deep-dive: study the genre's promises and mandatory/optional elements before choosing it.
Every economy is made of faucets (inflows: drops, rewards, regeneration) and sinks (outflows: purchases, repairs, consumables, upgrades). Their balance determines whether the currency stays meaningful.
Every resource should pose a question: spend now or save for later?
Deep-dive: "game economy design"; spreadsheet balancing (Machinations).
Progression gives a sense of growth. Distinguish two axes that age differently:
Mix the two: levels/gear (vertical) + abilities that change how you play (horizontal). All-vertical progression soon makes old enemies trivial and new ones mandatory.
Deep-dive: "horizontal vs vertical progression"; skill-tree design.
The goal isn't to make everything "the same", but to guarantee viable diversity: more valid options depending on context. The enemy of balance is the dominant strategy, which makes one choice optimal and all the others traps.
Symmetric (same resources, e.g. chess) or asymmetric (different roles, e.g. StarCraft): asymmetric is richer but much harder to balance.
Deep-dive: "dominant strategy"; iterative balancing in competitive games.
Not all randomness is equal. The key distinction is when it happens relative to the player's decision:
Use pity timers / pseudo-RNG (e.g. the probability rises with each failure) to limit negative streaks perceived as "cheating". The perception of fairness matters more than the math.
Deep-dive: "input vs output randomness"; pseudo-random distribution (Dota).
Difficulty shouldn't exclude: you can offer a high challenge and open the game to everyone.
Accessibility (remapping, colorblindness, subtitles) widens the audience and is an ethical choice, not an "extra".
Deep-dive: Celeste's Assist Mode; the "Game Accessibility Guidelines".
Costs and rewards scale along curves, and the shape of the curve is design.
Near-linear rewards with exponential costs: the player feels continuous progress without breaking the economy. Always model the numbers in a spreadsheet before putting them in the game.
Deep-dive: balancing spreadsheets; "diminishing returns" in power systems.
Feedback loops govern whether a match "closes out" early or stays contested.
Competitive games need both: positive rewards strong play, negative avoids "already over" matches. Too much negative, though, punishes good play and waters down merit.
Deep-dive: "positive/negative feedback loops"; rubber-banding in racing games.
When and how you save defines the tension and the respect for the player's time. It's a design choice, not just a technical one.
→ Deep-dive: connect to "Death loop, retry & penalty".
How you handle death determines whether the player retries or quits. The principle: a penalty that's felt, a fast restart.
→ Deep-dive: Celeste (instant retry) vs roguelite (loss of the run).
Finding, managing and equipping is the heart of ARPGs and survival games. The risk is turning management into friction instead of play.
→ Deep-dive: see "Tables: spawn, loot, enemy" in Technical Design.
Customization systems give expression and replayability. The danger is the dominant build, which kills variety.
→ Deep-dive: connect to "Meaningful decisions" and "Anti-pattern: choices & strategies".
Optional goals that extend the game's life and give purpose to those who want to push further. The best ones teach you to play better.
→ Deep-dive: avoid achievements that only reward time spent.
Progression that lives between sessions gives a sense of advancement even when a single run fails. It must be dosed: too much removes challenge, too little discourages.
→ Deep-dive: too much meta = "win by waiting"; balance it against player skill.
Luck gives variety and surprise; control gives mastery and fairness. The dosage defines the game's character. Systems that combine generate emergent stories.
→ Deep-dive: T. Sylvester, Designing Games (RimWorld); see "Randomness / RNG".
Adding other players multiplies complexity on three fronts: design, technical and social management.
→ Deep-dive: rollback netcode (GGPO); the social design of Overwatch and Among Us.
Relationship systems turn bonds into a measurable mechanic: they give purpose to social acts and reward investment over time. The heart of life-sims, dating sims and many RPGs.
→ Deep-dive: the social links of Persona; the "hearts" of Stardew Valley; see "Character & dialogue".
Spatial building is different from crafting (recipes): here where and how you place things is what matters. The heart of survival, base/city builders and tower defense.
→ Deep-dive: the building of Factorio and city builders; see "Crafting, build & skill tree".
Time can be a resource, a setting or a pressure. Handled well it gives rhythm and life to the world; handled badly it becomes stress or boredom. Central to life-sims, survival, stealth and immersive sims.
→ Deep-dive: the 3-day cycle of Majora's Mask; the schedules of Stardew; see "Cooldown & timing".
Structures give shape to the story, but in games they must be bent to interactivity: the player acts, doesn't watch.
A useful tool: think in terms of player arcs (what they learn/feel) alongside character arcs.
Deep-dive: kishōtenketsu in game design; narrative design vs game writing.
You tell the story through the world instead of exposition: a messy room, ruins, writing on the walls, two skeletons embracing. The player actively reconstructs the story — stronger participation than a line of read dialogue.
Masters: Dark Souls (lore almost entirely environmental), Gone Home, Hollow Knight, BioShock.
Deep-dive: Harvey Smith & Matthias Worch's talk "What Happened Here?".
Two sources of storytelling:
Want a precise, impactful moment? Embedded. Want infinite, personal stories at low cost? Emergent. Dwarf Fortress and RimWorld thrive on the emergent; a narrative adventure on the embedded. They almost always combine.
Deep-dive: "emergent narrative"; system-generated stories in sims.
It's the coherence (or conflict) between what the gameplay says and what the story says. Dissonance: the "compassionate" protagonist who nonetheless slaughters hundreds of enemies. Harmony: the gameplay expresses the theme.
Aim for the mechanics to tell the same thing as the plot.
Deep-dive: Clint Hocking on "ludonarrative dissonance" in BioShock.
Terms borrowed from film. Diegetic = exists inside the game world and characters can perceive it; non-diegetic = it's only for the player.
Diegetic UI to maximize immersion (horror, sim); non-diegetic to maximize clarity (competitive, strategy). Often a calibrated mix.
Deep-dive: the diegetic UI of Dead Space; UI taxonomies (diegetic/spatial/meta/non-diegetic).
Show through action and detail instead of explaining in words. In worldbuilding the iceberg theory applies: for every visible thing, let a much larger world be sensed below the surface.
Examples of worlds suggested more than explained: Hollow Knight, Hyper Light Drifter, Dark Souls.
Deep-dive: "iceberg theory" applied to worldbuilding in games.
A living character has a desire (what they want), a need (what they truly require), an arc (how they change) and a recognizable voice (they speak in a unique way).
Useful technique: give every character a goal within the scene, so the dialogue has tension.
Deep-dive: character writing in Disco Elysium and Hades; tools like ink/Yarn.
Quests interweave gameplay and story. A good mission has clear and motivated objectives, not just "bring X to Y".
→ Deep-dive: the best side quests tell something the main story can't.
Choices that truly matter require visible consequences. Pure branching is costly: it's often better to diverge and then reconverge.
→ Deep-dive: one visible consequence is worth more than ten invisible branches.
Characters and lines do double duty: gameplay (they guide, sell, challenge) and character (they bring the world to life).
→ Deep-dive: every line of dialogue should do at least two things.
World and story are delivered best in small doses scattered around, letting the player connect the dots (show, don't tell).
→ Deep-dive: the "iceberg theory" — suggest more than you say.
Making story and a repetitive structure (roguelite, sim) coexist is a challenge of pacing: when and how much to tell between gameplay.
→ Deep-dive: Hades advances the story with every death instead of interrupting it.
Tone and theme are the glue that holds mechanics, art and writing together. Consistency here makes everything more memorable.
→ Deep-dive: see "Ludonarrative dissonance" and Papers, Please.
Choose a base resolution early and design everything around it: it defines the "density" of your world and how much information fits on screen. Draw sprites at their native size, not large-to-shrink (you'd lose control of the individual pixel).
320×180 (modern 16:9, scales well to 1080p), 256×224 (SNES flavor), 384×216Deep-dive: Saint11's "Pixel Art Tutorial" guide; pixel-perfect viewport settings in Godot.
Working with limited palettes gives cohesion and speed (and an authentic retro flavor). The technical breakthrough is thinking in ramps: sequences of colors for shading, not simple darkenings.
In shadows, shift toward cool colors (blue/purple), in highlights toward warm ones (yellow/orange): don't just lower/raise the brightness of the same color, or you'll get "dead" images. Reuse ramps across objects for chromatic unity.
Deep-dive: "Pixel Logic" (Michael Azzi); palettes on lospec.com; the hue-shifting technique.
To keep pixels crisp, scale only to integer multiples (2×, 3×, 4×): fractional scaling creates pixel rows of uneven thickness ("dirty pixels").
Decide early: "pure" pixel-perfect or allow sub-pixel movement (smoother but less "retro")? It's an identity choice.
Deep-dive: "pixel snapping" in Godot; articles on 2D camera jitter.
Two techniques for "cheating" with few colors:
Both should be used sparingly: too much dithering "dirties", too much AA "blurs" the pixel look. Apply them where they improve readability (edges of soft shapes), not everywhere.
Deep-dive: Saint11 tutorials on dithering and selective AA.
Pixel animation lives on well-chosen key poses more than on many frames. Apply the classic principles even at 8×8: anticipation (wind-up before the action) and follow-through (the "bounce" after).
Tool of choice: Aseprite (onion skinning, timeline, tags).
Deep-dive: the 12 principles of animation applied to pixel; Saint11 tutorials.
The silhouette is the most important test: if you fill the sprite with black, it must stay recognizable. Characters and enemies must "read" at a glance, even small and in motion.
If two important elements have similar silhouettes, redesign: visual confusion is frustration.
Deep-dive: the "silhouette test"; readability in pixel character design.
2D worlds are built from repeatable tiles. The care lies in making them seamless (no visible joins) and in creating transition tiles between different terrains.
Draw tiles with repetition in mind: avoid patterns too recognizable that "wallpaper" the eye.
Deep-dive: autotiling in Godot 4; the 47-tile model and Wang tiles.
Techniques that give depth and atmosphere to a flat 2D scene:
Use them to serve readability and atmosphere, not as an effect for its own sake (the CRT shader, for example, can reduce readability: make it optional).
Deep-dive: CRT shaders in Godot; normal mapping on 2D sprites; the look of Dead Cells (3D rendered into pixels).
Organize animations for clarity and frame economy: a few well-chosen frames communicate more than many soft interpolations.
idle · walk · run · jump · fall · attack · hit · death.player_run_01) for a clean import.→ Deep-dive: Aseprite (tags per state, atlas export) is the indie standard.
Collision often doesn't coincide with the sprite: separate them for predictable, readable movement.
→ Deep-dive: in Godot, TileSet with physics/terrain layers and custom data layers.
What matters isn't the still sprite in the editor, but how it reads in motion, in the chaos of gameplay.
→ Deep-dive: connect to "Palette for gameplay readability" and "Visual readability".
Communicate hits and events with readable and disciplined effects: an excess of particles hides the gameplay.
→ Deep-dive: coherent audio + animation + VFX = convincing impact ("juice").
Give depth to a flat scene with layers at different speeds, without the decoration disturbing the gameplay.
→ Deep-dive: keep the decorative foreground transparent or out of the action zones.
Pixel-art interfaces must stay readable and well scaled, consistent with the game's base resolution.
→ Deep-dive: for hierarchy, HUD and readability at a distance see the UX & UI category.
Flow (Csíkszentmihályi) is the state of total immersion in which you lose track of time. Three conditions enable it: clear goals, immediate feedback, and balance between perceived challenge and skill.
Flow is not the only valid state (cozy games seek calm, not flow), but it's the reference point for challenge-based games.
Deep-dive: Mihály Csíkszentmihályi, "Flow"; the "flow channel" in game design.
Self-Determination Theory (Deci & Ryan) identifies three psychological needs that, when met, generate intrinsic motivation (playing for the pleasure of it, not for rewards):
Extrinsic rewards (currency, badges) work short-term, but healthy retention comes from intrinsic motivation. Design so the player wants to play, not because they feel obligated.
Deep-dive: applications of SDT to games (Rigby & Ryan, "Glued to Games").
From the psychology of conditioning: fixed ratio (a reward every N actions) is predictable; variable ratio (an unpredictable reward) is the most engaging — it's the principle behind slot machines and rare drops.
Use variability for the joy of surprise, not to trap.
Deep-dive: Skinner and "reinforcement schedules"; loot box ethics.
Bartle's model (born from MUDs) distinguishes four motivations:
Design for multiple motivations at once (collectibles for achievers, secrets for explorers, etc.). A modern, granular model: the 6 motivations of Quantic Foundry.
Deep-dive: Bartle's taxonomy; Quantic Foundry's "Gamer Motivation Model".
The player's mind has limited bandwidth: introducing too many mechanics at once causes overload and abandonment. The solution is progressive disclosure: reveal one concept at a time, when it's needed.
Teach by playing, not with walls of text or passive tutorials.
Deep-dive: "cognitive load"; onboarding and tutorial design (e.g. analyses of Half-Life).
Accessibility is both ethics and opportunity (a larger audience). It's not a "final extra": it should be considered from the start.
Often what helps players with disabilities improves the experience for everyone.
Deep-dive: "Game Accessibility Guidelines"; the work of AbleGamers and Can I Play That?.
Cognitive levers that move behavior — powerful and to be handled responsibly:
These patterns can create healthy engagement (curiosity, goals) or toxic compulsion (manipulation). The difference is whether they serve the player's fun or their exploitation.
Deep-dive: "dark patterns in games" (Zagal et al.); applied behavioral psychology.
A challenge is accepted only if it's perceived as fair. Player trust is fragile: one "unfair" death can break the whole experience.
→ Deep-dive: "hard but fair" retains; "unfair" drives players away.
Not all frustration is bad: productive frustration motivates, sterile frustration repels. The difference lies in the perception of control.
→ Deep-dive: defeat should point the way, not slam a door.
Much of the fun is the pleasure of learning and then mastering: the game makes you feel more skilled than yesterday.
→ Deep-dive: R. Koster, A Theory of Fun — fun is learning patterns.
Why the player comes back tomorrow, in a healthy way (curiosity and purpose) and not compulsively (manipulative loops).
→ Deep-dive: Stardew Valley — the "just one more day" comes from many small open purposes.
Moment by moment, the player assesses danger and progress. How much cognitive load they can bear while acting is a design limit.
→ Deep-dive: C. Hodent, The Gamer's Brain; see "Motivation (SDT)".
Psychological levers (see "Biases" and "Reward schedules") can create healthy engagement or toxic compulsion. The difference is whether they serve the player or exploit them.
→ Deep-dive: C. Hodent, "The Gamer's Brain"; "dark patterns in games" (Zagal et al.); see "F2P & ethical monetization".
The player journey (Amy Jo Kim) describes how the player's roles and motivations change across their "lifecycle": what a beginner needs isn't what keeps a veteran around.
→ Deep-dive: Amy Jo Kim, "The Player's Journey"; see "Cognitive load & onboarding" and "Retention".
Pillars are 3–5 guiding principles that capture the essence of the game (e.g. "constant tension", "joyful movement", "every death teaches"). They're the compass against which to measure every decision.
For a solo dev, pillars prevent drift: they remind you which game you're making when the tenth brilliant idea arrives.
Deep-dive: "design pillars" / "creative pillars" in vision documents.
Scope creep — the uncontrolled expansion of features — is the number-one cause of indie games that are never finished. Ideas multiply for free; time doesn't.
Deep-dive: "Blood, Sweat, and Pixels" (Jason Schreier) for real cases of scope.
The purpose of a prototype is to find the fun as fast as possible, with crude, throwaway means. It's not "clean code": it's a question to be answered.
A prototype that proves the idea doesn't work is a success: it saved you months.
Deep-dive: "find the fun"; rapid prototyping (e.g. the challenges of Kyle Gabler's team / Experimental Gameplay).
A vertical slice is a small but complete and polished portion at final-product quality: usually a real level/area with finished art, audio, UI and juice. It demonstrates "what the game will be like".
Different from a prototype (crude, to find the fun): the slice is beautiful and finished.
Deep-dive: "vertical slice" in publisher pitches; difference from "prototype" and "demo".
For solo/small teams, documents must be lean and alive. A one-pager (pitch, pillars, core loop, look, references) almost always beats a 200-page GDD that no one will update or read.
The document is there to think and align, not to impress. Keep it updated or it becomes fiction.
Deep-dive: "one-page design doc" (Stone Librande, GDC); agile GDDs.
Playtesting is the only way to know what the game is really like. Test early and often, even on ugly prototypes.
Gather the data, interpret it yourself, make one targeted change, retest. Iteration is the real engine of quality.
Deep-dive: "playtesting" (Schell, dedicated chapter); observation vs surveys.
Development is a cycle, not a straight line: design → prototype → playtest → iterate → polish → ship, repeated at various scales.
Always keep the game in a "playable" state (an evolving vertical slice) so you can test continuously.
Deep-dive: "production phases" (pre-production, production, polish, ship).
A typical toolchain for a 2D/pixel indie:
Choose tools that remove friction: for a solo dev, time is the scarcest resource.
Deep-dive: Godot + Aseprite + Tiled workflows; asset management with Git LFS.
Breaking the project into manageable milestones makes development navigable and measurable.
→ Deep-dive: an explicit cut list is the antidote to scope creep.
Keeping the project healthy and shippable avoids a collapse in the final stages.
→ Deep-dive: J. Schreier, Blood, Sweat, and Pixels for production risks.
Knowing how to say "it's done" is as much a production skill as knowing how to start. Polish has diminishing returns.
→ Deep-dive: better small and finished than huge and abandoned.
A small library covering theory, "feel" and production reality:
Start with Schell (broad) and Swink (if you make action/platform games).
Deep-dive: for pixel art, "Pixel Logic" by Michael Azzi (see the dedicated card).
Channels and video archives for learning by watching examples taken apart:
Watch actively: always ask yourself "why this choice?", don't just consume.
Deep-dive: look up GDC talks on the games you love (postmortems and deep dives).
To learn pixel art (see also the whole Pixel Art & 2D category):
Practice with constraints: small dimensions, reduced palettes; study the sprites of games you love pixel by pixel.
Deep-dive: hue shifting, the silhouette test and dithering in the Pixel Art & 2D cards.
Where to publish, learn and get noticed:
Build a small public presence (devlog, screenshots, Steam wishlist) during development, not after.
Deep-dive: wishlists and the Steam page as marketing tools from day one.
Game jams are the best accelerator for beginners: a theme, a tight deadline, and the obligation to deliver something finished. They teach realistic scope better than any book.
Key lesson: finishing a small game is worth more than starting ten big ones. Winning is secondary; delivering is everything.
Deep-dive: the value of creative constraints; postmortems of games born from a jam (e.g. Vampire Survivors draws on simple ideas).
A recap of the frameworks referenced in this guide, with their origins:
Deep-dive: each has a dedicated card or a reference in this guide.
Lean documents that actually get updated are worth more than a huge GDD nobody reads.
→ Deep-dive: Stone Librande's "one-page design" (GDC talk) is the classic reference.
Checklists so you don't forget the essentials in repetitive, oversight-prone phases.
→ Deep-dive: there are established public checklists for accessibility (e.g. industry guidelines) and the Steam page.
Build your own reference library: actively studying games and their postmortems accelerates growth.
→ Deep-dive: for every design choice you observe, ask yourself "why?".
Typical 2D indie tools, organized by domain. Choose them based on your workflow, not the hype.
→ Deep-dive: for asset/tool licenses see the Legal & Licensing category.
UX guides the player's attention: critical information must stand out without having to be searched for. Visual hierarchy is the main tool.
→ Deep-dive: C. Hodent, The Gamer's Brain, on perceptual principles in UI.
The HUD communicates state in real time. The guiding principle is to show only what's needed now (progressive disclosure), avoiding the "noisy UI".
→ Deep-dive: every HUD element must "earn" its place on the screen.
The flows outside the game matter as much as those inside it: a confusing menu is friction the player hits every session.
→ Deep-dive: a good menu is navigated with your thumb without having to think about it.
Dense interfaces (inventories, maps) must be made comprehensible: the goal is to reduce the friction between intention and action.
→ Deep-dive: a readable map is half the wayfinding job.
Teach at the right moment, with minimal text. The best tutorial is often the level itself, not a wall of opening instructions.
→ Deep-dive: see "Teaching through design" and Super Mario Bros. 1-1.
A useful taxonomy (popularized by analyses of video game UI) for choosing the right trade-off between immersion and clarity.
→ Deep-dive: diegetic = immersion; non-diegetic = clarity. They often coexist.
Mobile isn't a miniature PC: the context (on the move, in bursts), input (fingers) and attention (short) all change.
→ Deep-dive: see "Controls (touch)" and "Game UX & visual hierarchy".
Archetypes are functional roles: each forces a different behavior on the player. A bestiary is a collection of "verbs" for the player.
→ Deep-dive: each archetype is a different "question" posed to the player.
An enemy isn't a sack of HP: it's a problem to solve and a tool for pacing. Its readability is essential.
→ Deep-dive: combining archetypes creates richer "compound questions".
Telegraphing is what makes a fight feel fair: the player can react because they saw the attack coming.
→ Deep-dive: the more lethal the attack, the longer and clearer the warning must be.
Most enemy AI is a readable state machine. The goal isn't "smart" AI, but understandable AI.
patrol → chase → attack → retreat → stunned.→ Deep-dive: "understandable" AI > "smart but opaque" AI.
The mix of enemies and the timing make the encounter more than any single enemy. A good fight is structured like a good level.
→ Deep-dive: connect to "Encounter & arena design" and "Pacing".
The boss is the final exam of what the player has learned. Tend to the pace as much as the difficulty: a boss that drags on tires the player.
→ Deep-dive: connect to "Telegraphing & windows" and "Fairness & trust".
Two complementary lenses on real players. The qualitative explains the "why" behind the quantitative's numbers.
→ Deep-dive: the qualitative guides the design, the quantitative validates it at scale.
Telemetry reveals the real experience, not the imagined one. Track with a purpose: every event must answer a question (and with consent — see Legal).
→ Deep-dive: collect only what you'll actually use to decide.
Visualizing the data turns raw numbers into identifiable problems across the map and over time.
→ Deep-dive: a spike in drop-off = a spike in difficulty or confusion.
Use the numbers to tune, without chasing them blindly: data guides, design decides.
→ Deep-dive: beware spurious correlations; validate hypotheses with playtests.
A poorly set-up test misleads more than it informs. Observed behavior is worth more than stated opinions.
→ Deep-dive: stay quiet and observe; step in only when the protocol calls for it.
Ask well, then rank what to fix: the player is right about the problem, rarely about the solution.
→ Deep-dive: turn feedback into testable design hypotheses.
A softlock (a state you can't get out of) frustrates more than any defeat. Prevent it by design and hunt it in testing.
→ Deep-dive: see "Logic puzzles" and "Checkpoints & frustration".
Positioning answers the question: why should someone notice your game among thousands? You need an immediate hook and a unique selling point.
→ Deep-dive: if you can't sum it up in one line, it's hard to sell.
Knowing your audience and competition before building reduces the risk of making a game nobody was looking for.
→ Deep-dive: position yourself near your references, but with a clear difference.
The store page is the storefront that converts the curious into wishlists. The capsule is your "manifesto" in a few pixels.
→ Deep-dive: test the capsule small, as it appears in the lists.
The trailer and demo show the game in action. For an indie they're often the most effective marketing assets.
→ Deep-dive: show the game right away; the first 6 seconds decide everything.
Indie marketing is mostly about building an audience during development. Wishlists accumulate over time, not a week before launch.
→ Deep-dive: start early and be consistent; trust is built over time.
How much and how to sell: the price must be consistent with the scope, genre and audience expectations.
→ Deep-dive: the price also communicates the game's "perceived value".
Launch is the beginning, not the end. Post-launch support and reviews feed visibility over time.
→ Deep-dive: positive Steam reviews increase visibility in the medium term.
Free-to-play models generate revenue from many micro purchase-decisions. The line between legitimate design and manipulation is thin and must be watched.
→ Deep-dive: "ethical monetization" and the work of Celia Hodent; see "Reward schedules" and "Ethical design".
Building a community is half the work; managing it over time is the other half — especially when something goes wrong.
→ Deep-dive: see "Wishlists & community" and "Post-launch & reviews".
Sound is half the feedback: you often "hear" an event before you "see" it. Good audio keeps the action readable even in the chaos.
→ Deep-dive: coordinate sound, animation and VFX — coherence sells the impact.
Adaptive music reacts to the game state, amplifying tension and relief without the player noticing.
→ Deep-dive: FMOD and Wwise handle dynamic transitions and layering.
Every sound communicates something specific. Consistency is the golden rule: same action → same sound, always.
→ Deep-dive: treat sounds as part of the state feedback (see UX).
Sound anticipates events and builds emotion. Sometimes what you remove matters more than what you add.
→ Deep-dive: in horror, well-judged silence scares more than a bang.
Keeping sound from tiring or annoying over long sessions is part of the design, not a technical detail.
→ Deep-dive: listen to a long session; whatever tires you out needs smoothing.
Every third-party asset has a license that defines its allowed uses. Reading it before integrating it avoids costly problems at launch.
→ Deep-dive: keep proof of licensing. This is not legal advice: when in doubt, consult an expert.
Copyright and trademark are different protections. Understanding the difference helps you avoid infringing on others' rights by accident.
→ Deep-dive: for concrete cases, see a lawyer; the rules vary by country.
Free code and generated content are handy, but they have rules. Documenting the origin and license of everything is a good habit.
→ Deep-dive: keep a register of dependencies and assets with their licenses.
If you collect data, you have responsibilities toward players. The guiding principle is minimization: collect only what you need.
→ Deep-dive: regulations like the GDPR vary by region; check the applicable requirements.
To publish, you must respect age ratings and store rules. Planning them early avoids surprises at launch.
→ Deep-dive: the rating affects marketing and availability by region.
Writing from the start to be translatable avoids redoing everything later. The golden rule: never "hard-code" text.
→ Deep-dive: design the UI for +30-40% text length.
The technical pitfalls that break translations almost always come from assembling sentences from pieces.
→ Deep-dive: "You have {n} apple/s" doesn't work everywhere; hand whole sentences to the translator.
Translating the words isn't enough: localization adapts the experience, culturalization avoids problematic content.
→ Deep-dive: give translators context; without it, even simple lines go wrong.
The final steps make the perceived difference: legible subtitles and a review in-game (not just on a sheet).
→ Deep-dive: subtitles are also accessibility (see "Subtitles & CC").
Separating the numbers from the code lets you iterate fast and puts balancing in the designer's hands.
→ Deep-dive: in Godot, custom Resources and @export for designer tuning.
Structuring the project for reuse and clarity reduces bugs and speeds up level building.
→ Deep-dive: well-named collision layers prevent "ghost" bugs.
A few patterns structure most of a game's behavior and reactivity.
→ Deep-dive: events reduce direct dependencies and therefore bugs.
Data tables feed the systems and centralize their balancing.
→ Deep-dive: keep them in external data so the designer tunes them, not the programmer.
Technical hygiene seems boring but saves hours: the build stays healthy and files are found instantly.
→ Deep-dive: boring conventions today = instant searches tomorrow.
Building internal tools accelerates iteration and gives the designer autonomy from the programmer.
→ Deep-dive: every hour spent on tooling pays back in dozens of iterations.
Every platform imposes technical requirements you must pass to publish. Planning for them early avoids costly delays.
→ Deep-dive: see "Age rating & store compliance"; Steamworks and platform-holder documentation.
Mistakes that bloat the game without adding depth. They often come from wanting to add instead of refine.
→ Antidote: a few deep systems (see "Depth vs complexity") and an explicit cut list.
When the player's decisions lose meaning, the game becomes a sequence of forced steps.
→ Antidote: real trade-offs (see "Meaningful decisions").
The mistakes that make a game feel unfair break the player's trust.
→ Antidote: fairness, telegraphing and a fast retry.
When growth and rewards stop motivating, the player senses the emptiness beneath the surface.
→ Antidote: meaningful rewards and a carefully tended progression curve.
Teaching and showing badly drives the player away in the very first minutes, where drop-off is highest.
→ Antidote: teaching through design (see UX) and a clear visual hierarchy.
Mistakes of pacing and coherence at a large scale, which only emerge over long play.
→ Antidote: rewarding backtracking and harmony between story and mechanics.
Super Mario Bros. 1-1 is the manifesto of teaching without text: the first level is an invisible tutorial, built to let you discover the rules safely.
→ Lesson: level design can teach better than any pop-up.
Celeste combines brutal precision platforming with exemplary accessibility, proving the two can coexist.
→ Lesson: hard and accessible aren't a contradiction.
Spelunky is the reference for readable procedural generation: levels are always different but fair and traversable.
→ Lesson: procgen works if it stays readable and fair. (Derek Yu wrote a book about Spelunky.)
Vampire Survivors distills a minimal core loop into one of the most gratifying experiences of the "survivor-like" genre.
→ Lesson: a simple loop + perfect reward pacing creates (healthy) addiction.
Hollow Knight is a metroidvania masterclass: a huge, interconnected map, dense atmosphere, rewarding backtracking.
→ Lesson: a well-made map is content in itself.
Into the Breach removes almost all chance: you see exactly what the enemies will do, and the challenge becomes a tactical puzzle.
→ Lesson: removing chance can make tactics deeper.
Hades redefined narrative in roguelites by folding death into the loop instead of suffering it.
→ Lesson: a repetitive structure can be the engine of the storytelling.
Balatro starts from the familiar rules of poker to build a roguelite deckbuilder of surprising depth.
→ Lesson: starting from familiar rules frees up room for depth.
Dead Cells fuses fast combat, shifting builds and a "flow and smash" rhythm, hybridizing rogue-lite and metroidvania.
→ Lesson: combat feel + build variety = very high replayability.
Portal teaches its "grammar" one concept at a time, in controlled environments, before combining them.
→ Lesson: teach systems like a language (see "Teaching through design").
Slay the Spire defined the modern roguelite deckbuilder: the deck grows during the run and every choice counts.
→ Lesson: the composition of the deck IS the gameplay.
Stardew Valley builds healthy retention on soft purposes and satisfying closures, with no punishing failure.
→ Lesson: the motivation to return comes from soft purposes, not pressure.
Papers, Please turns a bureaucratic mechanic into a powerful ethical dilemma: the rule is the theme.
→ Lesson: a single mechanic can carry a deep theme.
Undertale subverts JRPG conventions and builds a direct, memorable relationship with the player.
→ Lesson: breaking a known convention creates unforgettable moments.