Pixel Art Palettes for Games (With Free Palettes to Download)

A fixed palette does more for a game’s art than almost any other decision. It’s the reason a game with sprites from three different artists, a tileset bought from an asset store and a few AI-generated props can still look like one game. It also makes every colour decision faster, because you’re choosing from 16 options instead of 16 million.

This guide covers how many colours to use, how to build ramps that don’t look muddy, how to check your values, and how to handle transparency. Then it gives you eight well-known free palettes with their exact hex values, ready to paste into Aseprite, GIMP or your engine. Every value below was taken from the palette’s own page on Lospec, and each palette is credited to its creator.

Why limit the palette at all

Hardware limits are long gone, so the reasons today are practical:

• Cohesion. When every sprite, tile and UI element draws from the same set of colours, they sit in the same world. This matters most when assets come from different sources.
• Readability. Fewer colours means bigger jumps between them, and those jumps are what make a 24-pixel character readable against a busy background.
• Speed. With five shades of green available, you pick one and move on. With a colour wheel, you fiddle.
• Consistency across animation. A character that picks up a few new anti-aliasing colours on each frame shimmers when animated. A locked palette prevents that.
• Cheap variants. Palette swaps, a red goblin and a blue goblin from one sprite, only work if colours are exact and few. More on this below.

How many colours

There are two different numbers to think about: colours in the whole game palette, and colours used in a single sprite.

If you aren’t sure, start with 16 or 32. A 16 or 32-pixel character rarely needs more than 8–12 colours including the outline, and most well-known indie pixel games keep individual sprites well below their full palette.

Here’s what a palette does to one sprite. The first knight is the original, generated with 14 colours. The other three are the same pixels mapped onto PICO-8, DawnBringer 16 and the four Game Boy greens:

PICO-8 has no mid grey-blue, so the steel armour shifts towards lavender; DB16 keeps it closer. The Game Boy version was mapped by brightness rather than nearest colour, which is why it still reads: with four shades, value is the only thing left.

Ramps and hue shifting

A ramp is a run of colours from dark to light that you use to shade one material. Skin might be a 4-colour ramp, a red cloak another, steel a third.

The beginner’s ramp is one hue at different brightness: the same red with black mixed in for shadow and white for highlight. It looks flat and muddy. The fix is hue shifting: as the colours get darker, rotate the hue toward cool (blue, purple). As they get lighter, rotate it toward warm (yellow). That imitates how real light behaves, with warm light and cool, sky-lit shadows, and it makes even a 3-colour ramp look rich.

A workable starting recipe, in HSB:

• 4–5 colours per ramp.
• Each step darker: hue rotates 10–20° toward blue/purple, brightness drops 12–18 points.
• Saturation peaks in the middle of the ramp and falls off at both ends. The darkest shade and the brightest highlight are both less saturated than the mid-tone.
• Avoid pure black (#000000) and pure white (#ffffff) inside ramps. A very dark blue-purple makes a better shadow and outline, and a pale cream makes a better highlight.

Look at Sweetie 16 below: the reds run from #b13e53 through #ef7d57 to #ffcd75, and that’s a hue shift from crimson to orange to warm yellow in three steps. Endesga 32 does the same with its blues, which pass through teal on the way to cyan.

Shared ramps

In a 16 or 32-colour palette you can’t give every material its own 5-step ramp. Ramps share colours instead: the darkest shade of skin might double as the mid-tone of wood. Good published palettes are built this way, which is a big part of why it’s worth starting from one rather than picking colours yourself.

Check your values

Value, or lightness, does more for readability than hue does. Two colours with different hues but the same value turn into one blob at small sizes, on a phone screen in sunlight, or for a colour-blind player.

The grayscale test: view your sprite or scene with all colour removed. Check that:

• the character’s silhouette is clearly lighter or darker than the background behind it;
• each ramp steps visibly from dark to light, with no two neighbours collapsing into the same grey;
• the things the player has to notice, like pickups, enemies and hazards, stand out in value, not just in hue.

How to do it:

• Aseprite: add a new layer on top, fill it with any mid-grey, and set its blend mode to Saturation (or Color). Toggle the layer to compare.
• Anywhere else: take a screenshot and desaturate it, or use your OS colour filters. macOS has Accessibility → Display → Color Filters → Grayscale, and Windows has Settings → Accessibility → Color filters.

To put numbers on it, relative luminance is roughly 0.2126 R + 0.7152 G + 0.0722 B on linear RGB. That’s why a pure blue (#0000ff) is far darker than a pure green (#00ff00) at the “same” brightness setting. Palette designers account for it. Hand-picked palettes often don’t.

One palette per game, not per sprite

Pick the palette at the start of the project, give it a name, and treat it as a dependency like your engine version.

• Characters and props use the full-contrast parts of the palette.
• Backgrounds use lower-contrast, usually cooler and less saturated, subsets so the playable layer pops.
• UI gets a few reserved colours that nothing in the game world uses, such as a specific gold for “interactive” or a red for “damage”, so players learn them.
• Effects (hits, magic, explosions) get the brightest, most saturated colours, used sparingly.

If you need more colours later, add them deliberately: extend a ramp, don’t drop in a random one-off shade.

Transparency and index 0

Pixel art lives with two kinds of image files:

• RGBA PNG. Each pixel stores its colour and alpha. This is what engines want for sprites. Make sure alpha is only ever fully opaque or fully transparent. Semi-transparent edge pixels from a soft eraser or a background-removal tool produce a halo in game.
• Indexed PNG / GIF. The image stores a palette (up to 256 colours) and each pixel stores an index into it. One index, conventionally index 0, is marked transparent.

Indexed mode is how most pixel artists work in Aseprite (Sprite → Color Mode → Indexed): every pixel must be a palette colour, so stray shades are impossible. Keep index 0 as the transparent colour and don’t use it in your art. PICO-8 does something similar: colour 0 (black) is treated as transparent when drawing sprites by default, so if you want solid black pixels in a sprite you have to change that with palt().

When you export for an engine, export RGBA PNG. When you need to keep files in a palette for palette swaps or archival, keep the indexed .aseprite or .png as the source.

Eight free palettes, with hex codes

All eight are free to use in commercial games. They’re listed with their authors and Lospec pages, where you can also download them as .png, .ase, .pal or .gpl. Hover a swatch to see its value.

PICO-8 (16 colours)

The fixed palette of the PICO-8 fantasy console by Lexaloffle. Bright, high-contrast and instantly recognisable. Its hue choices are idiosyncratic (there’s no true dark red), which forces creative solutions. Great for game jams. PICO-8 on Lospec.

000000
1d2b53
7e2553
008751
ab5236
5f574f
c2c3c7
fff1e8
ff004d
ffa300
ffec27
00e436
29adff
83769c
ff77a8
ffccaa

DawnBringer 16 (16 colours)

Created by DawnBringer on PixelJoint and one of the most influential pixel-art palettes ever made. Earthy and balanced, with carefully shared ramps. If you want a 16-colour palette that handles characters, foliage and stone equally well, start here. DB16 on Lospec.

140c1c
442434
30346d
4e4a4e
854c30
346524
d04648
757161
597dce
d27d2c
8595a1
6daa2c
d2aa99
6dc2ca
dad45e
deeed6

Sweetie 16 (16 colours)

By GrafxKid. Softer and more modern than DB16, with a lovely warm red-to-yellow ramp and a cool blue-to-cyan ramp, plus a slate-grey ramp. It’s the default palette in the TIC-80 fantasy console. Sweetie 16 on Lospec.

1a1c2c
5d275d
b13e53
ef7d57
ffcd75
a7f070
38b764
257179
29366f
3b5dc9
41a6f6
73eff7
f4f4f4
94b0c2
566c86
333c57

Endesga 32 (32 colours)

By ENDESGA. Vivid, saturated and built from long hue-shifted ramps. It’s one of the most-used palettes in modern indie pixel art. 32 colours give you proper ramps for skin, foliage, water and metal. Endesga 32 on Lospec.

be4a2f
d77643
ead4aa
e4a672
b86f50
733e39
3e2731
a22633
e43b44
f77622
feae34
fee761
63c74d
3e8948
265c42
193c3e
124e89
0099db
2ce8f5
ffffff
c0cbdc
8b9bb4
5a6988
3a4466
262b44
181425
ff0044
68386c
b55088
f6757a
e8b796
c28569

Nintendo Game Boy, BGB (4 colours)

The green-tinted four-shade look of the original Game Boy screen, as used by the BGB emulator. Four values and nothing else, which makes it the best possible exercise in value control. Game Boy (BGB) on Lospec.

081820
346856
88c070
e0f8d0

Apollo (46 colours)

By AdamCYounis. Organised as clean ramps by hue family (blues, greens, browns, oranges, reds, purples, and a long neutral ramp), which makes it unusually easy to learn. A good choice when you want more room than 32 colours without losing structure. Apollo on Lospec.

172038
253a5e
3c5e8b
4f8fba
73bed3
a4dddb
19332d
25562e
468232
75a743
a8ca58
d0da91
4d2b32
7a4841
ad7757
c09473
d7b594
e7d5b3
341c27
602c2c
884b2b
be772b
de9e41
e8c170
241527
411d31
752438
a53030
cf573c
da863e
1e1d39
402751
7a367b
a23e8c
c65197
df84a5
090a14
10141f
151d28
202e37
394a50
577277
819796
a8b5b2
c7cfcc
ebede9

AAP-64 (64 colours)

By Adigun A. Polack. A broad, vibrant 64-colour palette with long ramps, suited to larger sprites and detailed environments. AAP-64 on Lospec.

060608
141013
3b1725
73172d
b4202a
df3e23
fa6a0a
f9a31b
ffd541
fffc40
d6f264
9cdb43
59c135
14a02e
1a7a3e
24523b
122020
143464
285cc4
249fde
20d6c7
a6fcdb
ffffff
fef3c0
fad6b8
f5a097
e86a73
bc4a9b
793a80
403353
242234
221c1a
322b28
71413b
bb7547
dba463
f4d29c
dae0ea
b3b9d1
8b93af
6d758d
4a5462
333941
422433
5b3138
8e5252
ba756a
e9b5a3
e3e6ff
b9bffb
849be4
588dbe
477d85
23674e
328464
5daf8d
92dcba
cdf7e2
e4d2aa
c7b08b
a08662
796755
5a4e44
423934

Resurrect 64 (64 colours)

By Kerrie Lake. Slightly muted, with excellent neutral and skin ramps. Very popular for RPG-style projects with large tilesets. Resurrect 64 on Lospec.

2e222f
3e3546
625565
966c6c
ab947a
694f62
7f708a
9babb2
c7dcd0
ffffff
6e2727
b33831
ea4f36
f57d4a
ae2334
e83b3b
fb6b1d
f79617
f9c22b
7a3045
9e4539
cd683d
e6904e
fbb954
4c3e24
676633
a2a947
d5e04b
fbff86
165a4c
239063
1ebc73
91db69
cddf6c
313638
374e4a
547e64
92a984
b2ba90
0b5e65
0b8a8f
0eaf9b
30e1b9
8ff8e2
323353
484a77
4d65b4
4d9be6
8fd3ff
45293f
6b3e75
905ea9
a884f3
eaaded
753c54
a24b6f
cf657f
ed8099
831c5d
c32454
f04f78
f68181
fca790
fdcbb0

Palette file formats

Copying hex values works everywhere, but most tools load palette files directly:

A .gpl file is easy to write by hand. Here is PICO-8 with its official colour names:

GIMP Palette
Name: PICO-8
Columns: 8
#
  0   0   0	black
 29  43  83	dark-blue
126  37  83	dark-purple
  0 135  81	dark-green
171  82  54	brown
 95  87  79	dark-grey
194 195 199	light-grey
255 241 232	white
255   0  77	red
255 163   0	orange
255 236  39	yellow
  0 228  54	green
 41 173 255	blue
131 118 156	lavender
255 119 168	pink
255 204 170	light-peach

To load a palette in Aseprite, open the palette panel’s options menu (the small icon above the colour swatches) and choose Load Palette. To make a palette always available, use Presets in that panel, or drop the file into Aseprite’s palettes folder (Edit → Preferences → Locate Configuration File shows where Aseprite keeps its files).

Applying a palette to art you already have

Most projects arrive at a palette after some art already exists: a placeholder character, an asset pack, AI output, a scanned sketch. Three ways to bring it in line:

Remap colour by colour. If the art already uses a small number of colours, map each one to its nearest palette colour, then fix any mapping that went wrong by hand. The free Palette Swapper recolours sprites to retro palettes in the browser, so nothing is uploaded. For matching one image’s colours to another’s, there’s also Palette Transfer.

Quantise from scratch. For photos, painted art or high-resolution AI images, use Image to Pixel Art. It downscales to your target size and locks the result to a palette in one step. If you want dithering, the separate Dithering Tool lets you control it. Expect to clean up afterwards. Automatic quantisation picks colours by distance, not by intent, so an eye might become the same colour as the shadow next to it.

Reduce first, then remap. If an image has hundreds of near-duplicate colours, run it through the Color Reducer to get down to 8–16 colours, then remap those to your palette. Two steps give you far more control than one.

To go the other way, take a reference image you like and pull its colours out with the Palette Extractor. It’s a quick way to start a custom palette that matches a mood board.

Palettes and AI-generated sprites

AI image models don’t think in palettes. Left alone they produce dozens of near-identical shades and soft, anti-aliased edges. Two things help.

First, ask for a colour limit at generation time. In AI Sprite Maker the generator has a max colours setting, and the API takes the same thing as the palette field (for example "palette": 16). The output is then quantised to that many colours, so it looks like pixel art rather than a blurry miniature painting.

Second, remap to your game palette afterwards. A max-colour limit gives you few colours, not your colours, so run the result through the Palette Swapper with your game’s palette. This two-step routine (generate with a limit, then remap) is how we keep AI-made props consistent with hand-drawn characters.

Palette swaps in the engine

Once sprites use exact palette colours, recolouring at runtime is a few lines of shader. This Godot 4 canvas shader swaps up to four colours, enough for an “enemy tier” variant or a player-2 costume:

shader_type canvas_item;

uniform vec4 from_color[4] : source_color;
uniform vec4 to_color[4] : source_color;
uniform float tolerance = 0.01;

void fragment() {
	vec4 c = texture(TEXTURE, UV);
	for (int i = 0; i < 4; i++) {
		if (distance(c.rgb, from_color[i].rgb) < tolerance) {
			c.rgb = to_color[i].rgb;
		}
	}
	COLOR = c;
}

Set the from_color values to the sprite’s original ramp and to_color to the replacement. For more than a handful of colours, the standard technique is a lookup texture: store each pixel’s palette index in the sprite’s red channel and sample a 1-pixel-tall palette texture with it. Then a recolour is just a different palette texture. Unity and Phaser can do the same thing with a custom material or pipeline.

Palette swaps are why exact colours matter. A sprite that went through lossy compression or was saved with a slightly shifted colour profile won’t match from_color, and the swap silently does nothing.

A short routine for a new project

1. Pick a published palette close to the mood you want: 16 colours for a small or jam game, 32 for most indie projects.
2. Set your editor to indexed mode with that palette loaded.
3. Draw one character and one tile, then run the grayscale test on them together.
4. Adjust the palette now, if at all. Changing it after 200 sprites is painful.
5. Write the palette’s hex values into your repo (a .hex or .gpl file next to the art) so every collaborator and tool uses the same source.
6. Remap anything imported, whether bought, generated or contributed, before it goes into the game.

Picking a palette is the cheapest art decision you’ll make that every later asset depends on. When you start animating with a locked palette, the walk cycle guide picks up from here. For getting finished sheets into an engine, see Godot 4, Unity or Phaser 3.