How to Get Started With Pixel Art for Games

Why Pixel Art is Perfect for Indie Games

If you're making a game by yourself, art is probably the thing that scares you the most. You can fumble your way through code -- there are tutorials for everything, and the logic clicks eventually. But art feels different. It feels like something you either "have" or you don't. Like you needed to start drawing when you were five years old, and if you didn't, you've already missed your window.

Pixel art breaks that assumption. It's the most forgiving visual style in game development because the constraints do half the work for you. When your canvas is 32 pixels wide, you can't draw a bad hand -- there aren't enough pixels to draw a hand at all. You're placing colored squares on a grid. The limitations force you toward simplicity, and simplicity reads well in games. A two-pixel eye and a three-pixel smile is all it takes for a character to have personality. You don't need anatomy skills or a drawing tablet or years of practice. You need a mouse and a free afternoon.

Some of the best-selling indie games of all time use pixel art: Celeste, Stardew Valley, Shovel Knight, Katana ZERO, Dead Cells, Hyper Light Drifter. These games aren't pixel art because their developers couldn't afford "real" art. They're pixel art because the style is beautiful, expressive, and instantly readable at a glance. It's not a fallback. It's a deliberate aesthetic choice that happens to also be the most accessible entry point for solo developers who want to make something that looks good without spending months learning to draw.

Choosing Your Canvas Size

The first decision you'll make is your sprite resolution -- how many pixels wide and tall each character, tile, or object will be. This single choice affects the look of your entire game, how long each asset takes to draw, and how much detail you can fit in. Here are the most common sizes:

• 16x16 pixels -- Classic NES-era style. Extremely constrained, but that's part of the charm. Every pixel matters, so your sprites will be simple and iconic. Tiles and characters are fast to draw. This is a great size for your first attempt because it's nearly impossible to overthink it -- there just aren't enough pixels to get lost in details.
• 32x32 pixels -- The SNES era. You get noticeably more room for detail while still working quickly. Characters can have visible facial features, distinct clothing, and more expressive poses. This is the sweet spot for most indie games and where many developers feel the best balance between speed and visual fidelity.
• 64x64 pixels -- Significantly more canvas to work with. Good for larger characters, detailed portraits, or games where you want a more refined look. The trade-off is that each sprite takes meaningfully longer to draw, so you'll produce fewer assets in the same amount of time.

Here's the most important tip about canvas size: pick one and stick with it for your entire game. A game where every sprite is 32x32 with a consistent style will always look more polished than a game where some sprites are 16x16, some are 24x24, and the proportions don't match. Consistency matters far more than resolution.

Color Palettes: Less is More

The most common beginner mistake in pixel art isn't bad shapes or wrong proportions -- it's using too many colors. When you have an unlimited color picker, the temptation is to grab a slightly different shade for every surface. A slightly lighter blue here, a slightly warmer yellow there. The result is a sprite that looks noisy and muddy, like a photograph that got shrunk down instead of something intentionally designed at a small scale.

Limit yourself to 8-16 colors total. Not per sprite -- for your whole game. This sounds extreme, but it's what gives pixel art its cohesive, deliberate look. When every sprite in your game shares the same small palette, everything looks like it belongs in the same world, even if your individual drawing skills are rough. The Pico-8 palette -- a famous set of 16 colors designed specifically for retro game development -- is a perfect starting point. It has warm and cool tones, a few neutrals, and enough range to draw almost anything.

When building your palette, think in color ramps: for each hue, pick 3-4 shades ranging from dark to light. A dark blue for shadows, a mid blue for the base, a light blue for highlights, and maybe a near-white for the brightest spots. Do the same for your greens, your skin tones, your browns. These ramps give you enough range to shade your sprites while keeping the total color count low. You can explore and generate palettes with our Color Palette tool.

Basic Pixel Art Techniques

You don't need to master a long list of advanced methods before you start drawing. But a handful of fundamental techniques will immediately make your sprites look better. These apply whether you're working at 16x16 or 64x64:

• Start with a silhouette. Before you add any detail or color, block out the entire shape of your sprite in a single flat color. If the silhouette is readable -- if you can tell what it is just from the outline -- the sprite will work. If the silhouette is confusing, no amount of shading or detail will fix it. This is the single most useful habit in pixel art.
• Work big to small. Get the overall proportions and pose right before you zoom in and start placing individual pixels. It's easy to spend twenty minutes perfecting a character's face and then realize the body proportions are wrong and you have to redo everything. Rough shapes first, details last.
• Avoid "jaggies." When you draw a diagonal line in pixel art, you get staircase-shaped steps. If the steps are uneven -- two pixels, then one pixel, then three pixels -- the line looks rough and jittery. Clean diagonals have consistent step lengths. Take a moment to smooth them out manually. The difference is subtle but it makes sprites look significantly more polished.
• Use outlines wisely. A solid black outline around your sprite will make it pop against any background, which is useful for readability. For a more refined look, try colored outlines instead -- use a darker shade of whatever color is inside the outline. A character's blue shirt gets a dark blue outline instead of a black one. This technique, sometimes called "sel-out" (selective outlining), gives sprites a softer, more integrated appearance.
• Pick a light source and commit. Choose one direction for your light -- top-left is the standard convention -- and shade every sprite in your game the same way. The side facing the light gets lighter colors, the opposite side gets darker. Consistent lighting across all your assets is one of those things players can't consciously identify, but they feel when it's missing.
• Dithering. By alternating two colors in a checkerboard pattern, you can create the visual impression of a third, blended color -- even though no blending is actually happening. This is a classic pixel art technique inherited from hardware limitations of older consoles. It works well for gradients and textures, but use it sparingly. Too much dithering makes sprites look noisy.

Your First Sprite: A Simple Character

Theory is useful, but the best way to learn pixel art is to draw something. Here's a step-by-step walkthrough for creating a basic character sprite. Don't worry about making it perfect -- the goal is to get something on screen that looks like a person.

That's a complete character. It will look simple, and that's fine. Simple characters in a consistent style look far better in a game than detailed characters with inconsistent proportions. You can try this right now in our Pixel Editor -- it runs in your browser, no download needed.

Animation Basics

A static sprite works, but even minimal animation makes your game feel dramatically more alive. The good news is that pixel art animation doesn't require many frames. At small resolutions, subtle movement goes a long way.

• Idle animation: 2 frames. Shift the character up by 1 pixel, then back down. This tiny bob gives the impression of breathing and keeps the screen from feeling frozen. Loop it on a timer.
• Walk cycle: 4 frames is enough. Two frames per leg -- left leg forward, neutral, right leg forward, neutral. At 16x16 or 32x32, this reads clearly and looks smooth.
• Jump: You can get away with a single frame. Squash the character slightly on launch (compress vertically by a pixel) and stretch at the peak (extend vertically by a pixel). The squash and stretch sells the motion even without in-between frames.

The key principle is that each frame should read clearly on its own. If you cover up every other frame in your animation and the remaining frames still look good individually, your animation will work. If any single frame looks broken or ambiguous, fix it before adding more frames.

Tools for Pixel Art

You don't need expensive software to make pixel art. Some of the best tools are free, and you can start with nothing more than a web browser:

• Pixel Editor (ours) -- Free, browser-based, no download or account required. Open it and start placing pixels immediately. Great for quick sprites and prototyping ideas.
• Sprite Lab (ours) -- Free sprite creation tool in the browser. Useful for building and iterating on game characters.
• Aseprite -- The industry standard for pixel art and pixel animation. It costs $20, but the animation timeline, onion skinning, and layer tools make it worth it if you're serious about pixel art. The source code is available to compile for free if you'd rather build it yourself.
• Krita -- A free, open-source painting application with pixel-art-friendly settings. It's more of a general-purpose art tool, but it handles pixel work well once you configure the brushes and turn off anti-aliasing.
• Piskel -- A free browser-based pixel art editor with built-in animation support. No installation needed, and it can export sprite sheets directly.

Start with whatever is most convenient. If you just want to see what pixel art feels like, open a browser tool and draw for ten minutes. If you get hooked and want more control, Aseprite is the natural next step. The tool matters less than the time you spend using it.