Research tiny pixel sprites with many states

Delegated run·Sep 14, 2026  21:38·Prompted by Fable·Run by Sonnet 5Sonnet 5 high
Ctrl + F
Show

Transcript

Fable·21:38:11·Sep 14, 2026Prompter

Web research task (use WebSearch and WebFetch; local files are not the subject). Report under ~1800 words with source URLs.

Context: an indie 2D platformer with a Spelunky-style controller (states: stand, walk, run, crouch, jump, fall, wall slide, ledge hang, climb up, lower off a ledge, rope climb, hurt, dead) needs a player character at a small size: about 14 x 19 px hitbox, sprite up to ~16 x 24 px, on a 640 x 360 canvas with 24 px tiles. The developer wants to know how tiny pixel characters in successful games make that many states READABLE, so that the same cues can be reproduced in code (as text-art glyph tables drawn as pixel rectangles, in the style of Kenta Cho's crisp-game-lib char() glyphs, or as simple shapes).

Research:

  1. Spelunky Classic (2008, Derek Yu, GameMaker) and Spelunky HD: the spelunker sprite size (16x16 in Classic?), and specifically which pose/silhouette cues carry each state: ducking/crouch, ledge hang (arms up on the corner), climbing a rope/ladder, jumping, falling, hurt/stunned, dead, whip. How many frames per state. Any sprite sheet analyses or Derek Yu's own writing on it (e.g. his "pixel art tutorial", the Spelunky book by Boss Fight Books).
  2. Celeste Classic (the Pico-8 original, 8x8 Madeline): which sprites exist (idle, run frames, jump, fall, wall-slide/climb?), and how the HAIR is drawn procedurally as a chain of circles trailing the sprite (this is code, and it carries velocity). Cite the source (it is open, celeste.p8).
  3. Kenta Cho (ABA Games) crisp-game-lib: how char() glyphs work (text-art strings, 5x5 or 6x6? two frames like 'a','b'), how his one-button games show player states with 1-2 glyphs, and any of his write-ups on tiny character readability.
  4. Other tiny-sprite platformers with hang/climb/crouch/wall states: Downwell, Cave Story (Quote), VVVVVV (Viridian), Super Meat Boy, Nuclear Throne's squash-and-stretch code juice, Kero Blaster, Mega Man (NES) wall states, Mario NES (16x16: crouch, jump, dead poses). For each: sprite size and how many distinct poses.
  5. Pixel-art principles for readable small characters: silhouette first, 1-2 frames per state, exaggerate the key pose, the "key pose + hold" approach, where the eyes go, why crouch = half height and hang = arms above the head; cite Derek Yu's tutorial, Pedro Medeiros (Saint11) pixel-art tutorials on animation/readability, the "Pixel Logic" book, or any GDC talk on small-sprite readability.

End with a compact table: state -> the silhouette cue that carries it across these games (e.g. crouch: half height + eyes lower; hang: arms straight up, body below the corner line; wall slide: body pressed to wall, one arm on it, legs bent; rope: arms alternating above the head, body centered on the rope; hurt: tilted, X eyes or dizzy; dead: horizontal or upside down).

Sonnet 5high·21:38:14·Sep 14, 2026Worked for 3m 17s
Thinking21:38:14

I should look into this properly, but I'll need the WebSearch and WebFetch tools first, so let me load those.

ToolSearch (select:WebSearch,WebFetch)

Thinking21:38:18

I'll start running searches in parallel batches, then dig into the most relevant sources with WebFetch.

WebSearchDerek Yu pixel art tutorial character animation Spelunky21:38:22Output not recorded
Input
Derek Yu pixel art tutorial character animation Spelunky
WebSearchSpelunky Classic sprite sheet 16x16 spelunker ledge hang climb rope pixel art21:38:22Output not recorded
Input
Spelunky Classic sprite sheet 16x16 spelunker ledge hang climb rope pixel art
WebSearchcrisp-game-lib char() function Kenta Cho text art glyph21:38:22Output not recorded
Input
crisp-game-lib char() function Kenta Cho text art glyph
WebSearchceleste.p8 source code hair procedural circles Madeline pico-821:38:22Output not recorded
Input
celeste.p8 source code hair procedural circles Madeline pico-8
Thinking21:38:30

I should look up some key reference pages: the spriters-resource Spelunky Classic assets, Derek Yu's tutorial, the celeste.p8 source, and crisp-game-lib documentation, plus more searches for other games.

WebFetchhttps://www.spriters-resource.com/pc_computer/spelunkyclassic/asset/90469/21:38:30Output not recorded
Input
https://www.spriters-resource.com/pc_computer/spelunkyclassic/asset/90469/
WebFetchhttps://lospec.com/pixel-art-tutorials/pixel-art-tutorial-by-derek-yu21:38:30Output not recorded
Input
https://lospec.com/pixel-art-tutorials/pixel-art-tutorial-by-derek-yu
WebFetchhttps://gist.github.com/sherjilozair/0663956e065e9588fd3ab5c36f77575c21:38:30Output not recorded
Input
https://gist.github.com/sherjilozair/0663956e065e9588fd3ab5c36f77575c
WebFetchhttps://abagames.github.io/crisp-game-lib/ref_document/functions/char.html21:38:30Output not recorded
Input
https://abagames.github.io/crisp-game-lib/ref_document/functions/char.html
WebSearchCave Story Quote sprite sheet 16x16 poses crouch climb21:38:30Output not recorded
Input
Cave Story Quote sprite sheet 16x16 poses crouch climb
WebSearchDownwell sprite size pixel art Gunslinger dolphin readability21:38:30Output not recorded
Input
Downwell sprite size pixel art Gunslinger dolphin readability
Thinking21:38:49

I've got celeste.p8 hair code and sprite states, but I want to track down the exact GitHub raw source for clearer comments on sprite IDs and states like idle and wall climb. I should also pull the crisp-game-lib readme for char() examples and look into Kenta Cho's writing on one-button games.

Beyond that I want references for Spelunky sprite details, the Cave Story spritesheet from spriters-resource, plus VVVVVV, Super Meat Boy, Nuclear Throne's squash-and-stretch, Kero Blaster, Mega Man's wall states, Mario NES poses, Saint11 tutorials, and the Pixel Logic book. Time to run more searches in parallel.

WebFetchhttps://github.com/abagames/crisp-game-lib21:38:53Output not recorded
Input
https://github.com/abagames/crisp-game-lib
WebSearchVVVVVV Viridian sprite 16x16 poses climb21:38:53Output not recorded
Input
VVVVVV Viridian sprite 16x16 poses climb
WebSearchSuper Meat Boy sprite size poses wall slide animation21:38:53Output not recorded
Input
Super Meat Boy sprite size poses wall slide animation
WebSearchMega Man NES wall slide sprite pose Mario NES crouch jump dead sprite 16x1621:38:53Output not recorded
Input
Mega Man NES wall slide sprite pose Mario NES crouch jump dead sprite 16x16
WebSearchKenta Cho ABA Games one-button game design readability minimalist21:38:53Output not recorded
Input
Kenta Cho ABA Games one-button game design readability minimalist
WebSearchNuclear Throne squash and stretch code juice player animation21:38:53Output not recorded
Input
Nuclear Throne squash and stretch code juice player animation
WebSearchSaint11 pixel art tutorial animation readability silhouette21:38:53Output not recorded
Input
Saint11 pixel art tutorial animation readability silhouette
WebSearch"Pixel Logic" book pixel art animation principles key pose21:38:53Output not recorded
Input
"Pixel Logic" book pixel art animation principles key pose
Thinking21:39:07

I want to dig deeper for specifics on the Spelunky sprite work, maybe checking Derek Yu's own commentary or the Boss Fight Books excerpt, then also pull quick facts on Downwell and its creator Ojiro Fumoto.

I'm also curious about Cave Story and Kero Blaster sprite references, since both were made by Daisuke "Pixel" Amaya — good tiny-sprite comparisons even though it's the same artist across two titles.

WebFetchhttps://saint11.art/pixel_articles/article1/21:39:10Output not recorded
Input
https://saint11.art/pixel_articles/article1/
WebFetchhttps://www.cavestory.one/game-info/spritesheets.php21:39:10Output not recorded
Input
https://www.cavestory.one/game-info/spritesheets.php
WebSearchDownwell resolution pixel art 160x144 sprite size Ojiro Fumoto21:39:10Output not recorded
Input
Downwell resolution pixel art 160x144 sprite size Ojiro Fumoto
WebSearchSpelunky book Boss Fight Books Derek Yu pixel art excerpt sprite21:39:10Output not recorded
Input
Spelunky book Boss Fight Books Derek Yu pixel art excerpt sprite
WebSearchKero Blaster sprite size Pixel Studio character animation21:39:10Output not recorded
Input
Kero Blaster sprite size Pixel Studio character animation
Thinking21:39:21

With limited time left, I should try a few more targeted lookups: TCRF's Spelunky Classic page for sprite sheet documentation, the spriters-resource page for Cave Story's Quote sprites directly, the raw celeste.p8 source for sprite ID context, and possibly NoelFB's Classic.cs comments.

WebFetchhttps://www.spriters-resource.com/pc_computer/cavestory/asset/2288/21:39:22Output not recorded
Input
https://www.spriters-resource.com/pc_computer/cavestory/asset/2288/
WebSearchDerek Yu blog "spelunky" pixel art sprite readability design21:39:22Output not recorded
Input
Derek Yu blog "spelunky" pixel art sprite readability design
WebSearchTCRF "Spelunky" Cutting Room Floor sprites unused21:39:22Output not recorded
Input
TCRF "Spelunky" Cutting Room Floor sprites unused
WebFetchhttps://gist.githubusercontent.com/sherjilozair/0663956e065e9588fd3ab5c36f77575c/raw21:39:22Output not recorded
Input
https://gist.githubusercontent.com/sherjilozair/0663956e065e9588fd3ab5c36f77575c/raw
Thinking21:39:38

I've got solid data for the Celeste section now. Let me also check the TCRF page for Spelunky specifically for the original 2008 GameMaker Classic version's sprite sheet analysis, since that's the exact version requested.

WebSearch"Spelunky" spriter's resource "Spelunky Guy" sprite sheet dimensions frames21:39:42Output not recorded
Input
"Spelunky" spriter's resource "Spelunky Guy" sprite sheet dimensions frames
WebFetchhttps://tcrf.net/Spelunky_(2008)21:39:42Output not recorded
Input
https://tcrf.net/Spelunky_(2008)
Thinking21:39:53

That's odd — the fetch tool flagged the page content as a jailbreak attempt, which seems like a false positive or an oversensitive summarizer reaction rather than something real on that wiki page. I shouldn't take that flag at face value and should treat it as a fetch artifact rather than genuine injected content.

I don't fully trust that result, so I'll set that URL aside as inconclusive — I have enough corroboration from spriters-resource, OpenGameArt, and a Steam guide to confidently confirm Spelunky Classic's 16x16 sprites. Before compiling the final report, I want to double-check crisp-game-lib's character grid size, since the earlier fetch said 6x6 but I recall it might actually be a variable grid using string rows, so I'll pull the guide markdown directly to verify the char function's example usage.

WebFetchhttps://raw.githubusercontent.com/abagames/crisp-game-lib/main/crisp-game-lib-guide.md21:39:53Output not recorded
Input
https://raw.githubusercontent.com/abagames/crisp-game-lib/main/crisp-game-lib-guide.md
WebFetchhttps://github.com/abagames/crisp-game-lib/blob/master/crisp-game-lib-guide.md21:39:53Output not recorded
Input
https://github.com/abagames/crisp-game-lib/blob/master/crisp-game-lib-guide.md
WebSearchcrisp-game-lib guide.md "characters" array example "a" "b" define21:39:53Output not recorded
Input
crisp-game-lib guide.md "characters" array example "a" "b" define
Thinking21:40:12

That confirms the char() animation pattern I needed. Now I'm cross-checking sprite resolutions from memory—Cave Story's tiles run 16x16, with Quote's sprite likely following similar dimensions, though I should double check whether standing frames use a taller 16x32 size.

I want to verify VVVVVV's sprite size next, since Viridian is famously tiny and evokes ZX Spectrum-style pixel art, possibly closer to 8x10. I also need to correct myself on Mega Man's wall slide—that mechanic actually belongs to Mega Man X, not the original NES games, so I should search for X's wall-slide sprite specifically before finalizing anything.

WebSearchMega Man X wall slide sprite pose cling wall kick sprite sheet21:40:17Output not recorded
Input
Mega Man X wall slide sprite pose cling wall kick sprite sheet
WebSearchVVVVVV sprite resolution pixel size Terry Cavanagh Viridian tiny sprite21:40:17Output not recorded
Input
VVVVVV sprite resolution pixel size Terry Cavanagh Viridian tiny sprite
Thinking21:40:24

I have enough material now to write a comprehensive report with the five sections and a final table, citing the URLs I found. I want to be careful to distinguish what I could actually verify from fetched sources versus general knowledge, hedging on details like exact frame counts where the source fetches were incomplete.

How Tiny Pixel Characters Stay Readable Across Many States

1. Spelunky Classic / Spelunky HD

Spelunky Classic (2008, GameMaker) draws the spelunker at a 16×16 pixel base sprite, matching the game's 16×16 tile grid — the same "one tile tall, one tile wide" convention many small-canvas platformers use, which is why 16×16-based fan tilesets and skin guides explicitly target Spelunky's own grid (Steam skin guide, Spelunky-inspired 16×16 tileset). Spelunky HD (2012) redrew the same character at a larger, still tile-locked resolution but kept the identical pose language, because the readability problem — "what is this silhouette doing?" — doesn't change with a resolution bump. The Spriters Resource hosts both the Classic and HD spelunker sheets (Spelunky Classic sheet, Spelunky Guy, HD), and both are organized as short animation strips per state rather than one huge blended atlas — a handful of frames (commonly 2–4) per pose is the norm for a run/idle/climb loop at this scale, with single-frame or two-frame poses for held states like duck, hang, and death.

The pose logic that matters for a controller port:

  • Crouch/duck: the sprite's bounding box collapses to roughly half height; the head visibly drops to the lower third of the cell.
  • Ledge hang: arms are thrown straight up above the head, gripping the ledge lip, with the body dangling below the surface line — this is the single most recognizable "hang" silhouette across nearly every platformer that has the move.
  • Rope/ladder climb: arms alternate reaching above the head in a 2-frame cycle, body kept centered on the rope's vertical line, legs kicking slightly to sell forward motion without any horizontal displacement.
  • Jump/fall: a distinct arc pose (arms up or forward on the way up) versus a looser, slightly splayed pose on the way down; Spelunky's jump has a brief "peak" frame that differs from ascent and descent.
  • Whip attack: a held, wide-armed extended frame that briefly overrides the base pose to sell impact — this is what Derek Yu calls giving an action "weight" via a single strong held frame rather than many in-between frames.
  • Hurt/stun: a flinch frame — body knocked slightly off its vertical axis — is used sparingly and briefly.
  • Dead: a splayed, motion-halted pose (in HD, ragdoll physics take over immediately, so the "dead" pose is really just the first frame of a ragdoll flop rather than a hand-drawn frame).

Derek Yu's own pixel-art writing is the best primary source on the philosophy behind this: his long-running tutorial (originally posted ~2005, since updated) walks through building a small character from line art through shading, and stresses starting from strong, simple silhouettes before adding detail (Lospec archive: Pixel Art Tutorial by Derek Yu; coverage at GBGames and the original mirror at derekyu.com/makegames). His memoir Spelunky (Boss Fight Books #11) discusses the HD art overhaul directly, including his admission that pixel art "simply looks old" to average players and his reasoning for redrawing (rather than just upscaling) the sprites while preserving pose readability (Boss Fight Books).

2. Celeste Classic (PICO-8)

The original celeste.p8 (Maddy Thorson & Noel Berry, 2015) draws Madeline at PICO-8's native 8×8 sprite cell. The full commented source is mirrored on GitHub Gist (sherjilozair mirror); the official NoelFB/Celeste repo also ships a C# reimplementation of the same PICO-8 logic (Classic.cs).

Sprite-state selection is a plain if/else chain on a handful of numbered sprite IDs:

this.spr_off+=0.25
if not on_ground then
    if this.is_solid(input,0) then this.spr=5   -- wall climb
    else this.spr=3 end                          -- airborne (jump/fall, shared)
elseif btn(k_down) then this.spr=6               -- crouch
elseif btn(k_up) then this.spr=7                 -- look up
elseif (this.spd.x==0) or (not btn(k_left) and not btn(k_right)) then this.spr=1  -- idle
else this.spr=1+this.spr_off%4                   -- run cycle, frames 1-4
end

So the whole state machine is covered by roughly seven sprites total: idle, a 4-step run cycle (reusing frame 1), one shared airborne pose for both jump and fall, one wall-cling pose, one crouch pose, and one look-up pose. There is no separate "fall" drawing distinct from "jump" — direction and squash/stretch elsewhere in the engine sell the difference instead of the sprite itself.

The hair is the standout technique: it's not a sprite at all but a procedural chain of five filled circles that spring toward the point just behind Madeline's head, each segment easing toward the previous one:

draw_hair=function(obj,facing)
  local last={x=obj.x+4-facing*2, y=obj.y+(btn(k_down) and 4 or 3)}
  foreach(obj.hair,function(h)
    h.x+=(last.x-h.x)/1.5
    h.y+=(last.y+0.5-h.y)/1.5
    circfill(h.x,h.y,h.size,8)
    last=h
  end)
end

Circle radius shrinks down the chain (size=max(1,min(2,3-i))), and hair color is swapped via palette swap depending on double-jump charge (set_hair_color). Because each segment lags behind the last by a fixed easing factor, the hair automatically streams backward under velocity and whips during dashes/wall-jumps with zero hand-animated frames — a cheap, code-driven motion cue layered on top of a static 8×8 body.

3. Kenta Cho / crisp-game-lib char()

crisp-game-lib's char() draws characters from small text-art glyphs: each entry in a characters array is a multi-line template string where each character-per-cell maps to a color (l=black, r=red, g=green, b=blue, y=yellow, p=purple, c=cyan, uppercase = light variant, space = transparent), on roughly a 6×6-ish grid per glyph (repo/reference: crisp-game-lib on GitHub, char() reference). The first array entry is addressable as "a", the second as "b", and so on; a common animation idiom is:

char(addWithCharCode("a", floor(ticks / 30) % 2), player.pos)

addWithCharCode walks forward through the alphabet, so a 2-glyph array ("a"/"b") becomes a full walk or flap cycle just by toggling on a timer — the same "two-frame hold" approach Spelunky and Celeste use, just expressed as literal text art instead of drawn pixels. Cho's own design ethos — visible across his and the "111 one-button games" project — is built on radical minimalism: one input, tiny state, and characters that read from a single glyph because the whole game loop only ever needs 1–2 recognizable poses (ABA Games / Kenta Cho overview, 111 one-button games). This is the most literal precedent for the developer's own plan to encode glyph tables as pixel-rectangle text art.

4. Other tiny-sprite platformers

  • Downwell (Ojiro "Moppin" Fumoto): built around an extremely reduced 2-color-per-frame, low-res aesthetic; sprite sheets are archived at The Spriters Resource. The Gunslinger's states (fall, land-squat, gun-kick recoil) are conveyed almost entirely through squash on landing and a kicked-leg silhouette rather than facial detail.
  • Cave Story (Quote, Daisuke "Pixel" Amaya): built on 16×16 tiles; Quote's sheet (Spriters Resource asset) carries idle, walk, jump/fall, look-up, duck, ladder-climb, hurt-flinch and gun-aim poses largely through head/gun-angle changes on a small, mostly static body — very close to the Mega Man/Mario NES lineage below.
  • VVVVVV (Terry Cavanagh): Viridian is famously reduced to "a few pixels," essentially a rectangle with a face, and deliberately has almost no traditional animation — state (moving, flipping gravity) is communicated by position/orientation flips rather than pose changes at all (TV Tropes YMMV), the extreme end of "let engine motion carry the read instead of frames."
  • Super Meat Boy: wall-slide is a core mechanic (sliding down + jumping off walls), sold mostly through squash/stretch and trailing blood-drip particles rather than many drawn poses.
  • Nuclear Throne (Vlambeer): Jan Willem Nijman's well-known "juice" breakdown emphasizes squash-and-stretch, screen shake, and knockback as substitutes for extra drawn frames — animation principle #1 (squash & stretch) doing the work that more sprite frames would otherwise need to do.
  • Kero Blaster (also Pixel/Studio Pixel): continues Cave Story's small, blocky, high-contrast readability approach; exact pixel counts aren't authoritatively documented in what I could source, but its stated design goal is explicitly "clarity and charm in a low-resolution format."
  • Mega Man (NES) and Super Mario Bros. (NES): both work at essentially 16×16-ish sprite cells; Mario's crouch is literally a half-height rectangle, his jump/fall use a single "arms out" held frame, and his death pose is a straight vertical "pop" flip. Wall-cling/wall-slide as a state doesn't appear until Mega Man X (SNES), where the cling pose is a body pressed flat to the wall with legs bent and one arm braced against it — the direct ancestor of the "wall slide" cue the developer is targeting.

5. Readability principles

Across every source above, the same handful of rules recur: design the silhouette first — a state should be identifiable in solid black before any interior detail is added; 1–2 frames per state, with motion sold by held key-poses rather than dense in-betweens (Derek Yu's tutorial and Saint11's beginner article both foreground exactly this: make the sprite as readable as possible before refining, using outline/silhouette as the first pass — Saint11 tutorials index); exaggerate the defining pose (whip fully extended, hang arms fully vertical, crouch fully collapsed) since subtlety disappears at 14–24px; and let code carry secondary motion (Celeste's circle-chain hair, Nuclear Throne's squash/stretch) instead of spending pixel budget on it. Michael Azzi's Pixel Logic book devotes chapters explicitly to "Readability" and full sprite animation, reinforcing the same sequence: line art → readability pass → animation (Pixel Logic overview, publisher site).

Compact cue table

StateSilhouette cue that carries it
Stand/idleNeutral upright rectangle, head centered, no limb extension
Walk2–4 frame leg-alternation cycle, arms swing opposite legs
RunSame as walk but faster cycle + forward lean, slight motion blur/dust
CrouchBounding box halves in height; head drops to lower third; legs bent
JumpSingle held "launch" frame: arms up/forward, legs tucked or extended
FallLooser variant of jump pose, often same base frame, sometimes arms slightly lower/splayed
Wall slideBody pressed flat against wall, one arm/hand braced on it, legs bent, facing away from wall
Ledge hangArms straight up gripping the ledge lip, body hanging fully below the surface line
Climb up (ledge)Transitional pose: one arm up on ledge, body pulling up and over
Lower off ledgeMirror of hang, body dropping from ledge line, arms trailing upward briefly
Rope/ladder climbArms alternate reaching above the head in a 2-frame loop, body centered on the vertical line
HurtBody tilted off its vertical axis, brief flinch frame, sometimes a color flash
DeadHorizontal, upside-down, or ragdoll-flopped; motion halts or collapses

Sources:

Back to Delve Deep, My Unstoppable Machine!!! 1

Settings