Pixel Art Sprite Sizes for Games: 16, 32 or 64?

The short answer

Pick the sprite size from the screen, not the other way round. Decide how many tiles the player should see across the screen, choose a low internal resolution that scales by a whole number to common displays (320×180, 384×216, 480×270 or 640×360), and divide. With 16×16 tiles, 320×180 shows 20 tiles across; with 32×32 tiles, 640×360 also shows 20. Both scale cleanly to 1920×1080 (6× and 3×). Most indie games land on 16 or 32 pixel tiles with characters one to two tiles tall.

What the common sizes are good for

Sprite size controls three things at once: how much detail a sprite can carry, how much art you have to produce, and how big the world feels on screen. Smaller sprites are faster to draw and animate, and they read better at a glance; larger sprites carry faces, armour detail and readable weapons, but every extra frame costs much more work.

How many tiles fit on screen

The internal resolution divided by the tile size gives the visible play area. This number shapes the design more than art style does: a dungeon crawler wants room to see enemies coming, a platformer wants enough horizontal space to plan jumps, a cosy farming game can afford a closer camera.

Note that 180 is not a multiple of 16, so a 320×180 screen shows 11.25 tiles vertically. That is normal and fine; the camera simply cuts a tile in half at the edge. If you need whole tiles vertically, 320×176 or 384×224 work, but they no longer scale to 1080p exactly.

Integer scaling, and what happens on other screens

Pixel art should be scaled by whole numbers so every source pixel becomes the same square block on screen. At 3× each pixel is 3×3; at 2.5× some pixels are 2 wide and some 3, and that unevenness shimmers whenever the camera moves. Render the whole game to a small surface at the internal resolution, then scale that surface up — do not scale individual sprites.

Not every screen is a multiple of your resolution. A 320×180 game on a 1280×800 display (Steam Deck) scales 4× to 1280×720 and leaves 40 pixels of border top and bottom. On a 1366×768 laptop it also scales 4× and leaves a border on all sides. Accept the border (filled with black or a frame), or allow a little extra visible area on those screens instead of a fractional scale.

• 1280×720: 320×180 at 4×, 640×360 at 2×.
• 1920×1080: 320×180 at 6×, 480×270 at 4×, 640×360 at 3×.
• 2560×1440: 320×180 at 8×, 640×360 at 4×.
• 3840×2160: 320×180 at 12×, 640×360 at 6×.

Character size versus tile size

Characters do not have to match the tile size exactly, but the pixel density must match: a 16px tile and a 32px character drawn at the same pixel scale look fine together; a 16px tile next to a 64px character that was shrunk to fit looks like two different games. Common pairings are a 16×16 tile with a 16×24 or 16×32 character, and a 32×32 tile with a 32×48 or 32×64 character.

Leave a little empty space in the frame for animation. A character that fills its 32×32 canvas edge to edge has no room to swing a sword or lean into a run. Many developers draw on a canvas a size up (48×48 for a 32px character) and keep the body centred, with the feet on the same row in every frame.

Setting it up in Godot, Unity and GameMaker

Every engine can do pixel-perfect scaling; the names differ.

• Godot 4: Project Settings → Display → Window: Viewport Width/Height 320×180, Stretch Mode 'viewport', Scale Mode 'integer' (Godot 4.2+). Rendering → Textures → Default Texture Filter 'Nearest'.
• Unity: set Pixels Per Unit on every sprite to your tile size (16 or 32), Filter Mode 'Point (no filter)', Compression 'None', and add a Pixel Perfect Camera with Assets PPU = the same value and Reference Resolution = 320×180.
• GameMaker: a room camera of 320×180 and a viewport of 1280×720 or 1920×1080; turn off 'Interpolate colours between pixels' in Game Options.

Checking a sprite's real pixel size

Many 'pixel art' images, especially from general AI image tools, are drawn at high resolution and only look pixelated. Zoom in: if the blocks are uneven, blurred at the edges or contain gradients, the image is not on a pixel grid and will never scale cleanly. Real pixel art can be scaled down by its block size with nearest-neighbour and back up without changing.

SpriteLab snaps its pixel styles (Pixel 16-bit, Pixel HD, Isometric Pixel) to one pixel grid and a limited palette, and delivers them pre-scaled by a whole number so they are easy to preview. Animation frames, for example, are 256 pixels tall: a 128-pixel grid doubled. If your game uses 32 or 64 pixel characters, scale the image down by the block size in a pixel editor (Aseprite: Sprite → Sprite Size with the Nearest-neighbor method) rather than in the engine, then clean up the few pixels that need it. The tool does not choose your game's resolution for you; that decision stays with you and should come first.

A decision checklist

Write these down before making any assets, and keep them in the project's readme:

1. 01Target display: 1920×1080 first, then the others you care about (Steam Deck, laptops, phones).
2. 02Internal resolution that divides into it: 320×180, 384×216, 480×270 or 640×360.
3. 03Tile size: 16 or 32 in most cases; check how many tiles fit on screen.
4. 04Character canvas: the tile size or one step larger, with feet on a fixed row.
5. 05Palette size and outline rule, shared by every sprite.
6. 06Engine settings: nearest filtering, no compression, integer scaling, whole-pixel positions.