Palette Swaps: How to Turn One Sprite Into an Entire Cast

The Trick That Built Gaming's Visual Vocabulary

Look at the green Koopas and red Koopas in Super Mario Bros. Same sprite, different colors. Look at the palette-shifted ghosts in Pac-Man, the "Ninja" archetypes in Double Dragon, the elemental enemy variants in every JRPG ever made. They're all the same move: take one sprite, swap the colors, call it a new enemy.

This wasn't an artistic flourish. It was an engineering necessity. The NES had 2 KB of RAM and could display roughly 64 unique 8×8 tiles on screen at once. Shipping eight distinct enemy sprites for what should be "the same enemy, but stronger" was impossible. Palette swapping let designers multiply their cast without multiplying their memory budget.

Four decades later, memory isn't the constraint — artist time is. And palette swapping is still the fastest way to turn one character into five. Let's dig into how.

Why Palette Swaps Still Work in 2026

Modern hardware could draw a unique 1024×1024 sprite for every enemy. So why do indie games like Hyper Light Drifter, Crypt of the NecroDancer, Eastward, and Celeste still palette-swap aggressively? Three reasons:

1. Visual consistency. When all your water elementals share a silhouette, players learn "blue rippling outline = water creature" instantly. Swap the palette to red and the player instantly understands "this one is fire." Your design communicates without a tutorial.

2. Production velocity. A solo dev can draw 4 unique enemies or draw 1 enemy and palette-swap it 4 times. Same visual variety, 75% less art time.

3. Balance iteration. When you discover halfway through development that an enemy type needs a harder variant, palette swap is instant. No new frames to draw, no animations to retime.

The modern meaning of palette swap isn't "we couldn't afford new art." It's "we deliberately used color as our design language."

How the NES Actually Did It

Understanding the original technique tells you why it works so well even today. The NES stored sprites as index-based tiles: each pixel in a tile was a 2-bit number (0–3), which pointed into a 4-color palette. The palette was stored separately from the sprite.

To create a variant, the game swapped the palette in memory. Same tile data. Same pixel positions. Different colors on screen.

That's the whole trick. The sprite "Koopa Troopa" and "red Koopa Troopa" are the exact same bytes of graphical data; they reference different 4-color palettes. On the NES, this consumed roughly 16 additional bytes per variant instead of the hundreds of bytes a new sprite would have needed.

The lesson that carried forward: if you design your sprite against a small, deliberately chosen palette, you unlock cheap variants forever.

Palette Swap Workflows in 2026

You can palette-swap three ways today, in increasing order of sophistication. Pick the one that matches your project.

Approach 1: Pre-Baked Variants (The Simple Way)

Keep it dead simple:

1. Draw your base sprite with a limited palette (say, 6 colors).
2. Make a copy of the sprite sheet for each variant.
3. Use a recolor tool to replace color #1 → color #2 → color #3 → etc.
4. Export each variant as its own sprite sheet.
5. Load the appropriate variant at runtime based on your game logic.

Pros: Works in every engine. No shader knowledge needed. Zero runtime cost.

Cons: Storage grows with variant count. If you have 50 enemy types × 4 variants each, you're shipping 200 sprite sheets.

For most indie games, this is totally fine. A 16×16 sprite at 200 variants is still kilobytes of data.

Approach 2: Runtime Color Replacement (Shader Method)

Instead of shipping multiple sheets, ship one — and swap colors at render time with a shader.

The idea: your sprite uses a known small palette (e.g. 16 colors). The shader is given two palettes — the original and a target. For each pixel, it finds the color in the original palette and outputs the corresponding color from the target palette.

A minimal GLSL palette swap shader (Godot / Unity compatible with small tweaks):

uniform sampler2D sprite_texture;
uniform vec4 source_palette[16];
uniform vec4 target_palette[16];

vec4 palette_swap(vec2 uv) {
    vec4 pixel = texture(sprite_texture, uv);
    for (int i = 0; i < 16; i++) {
        if (distance(pixel, source_palette[i]) < 0.01) {
            return target_palette[i];
        }
    }
    return pixel;
}

Pros: One sprite sheet, infinite variants. Change palettes at runtime. Flash effects, damage indicators, team colors — all one uniform away.

Cons: Requires shader support. Runtime cost per pixel (cheap on modern hardware, noticeable on ancient mobile). Palette must be small enough to fit in a uniform.

Approach 3: Palette Texture Lookup (The Pro Move)

Instead of looping through palette arrays, store the palette as a tiny texture. The sprite's "color" is actually an index into this palette texture — which means swapping the palette is literally a texture swap.

This is how Crypt of the NecroDancer and Enter the Gungeon handle their extensive color variants. A single sprite, a tiny palette texture per variant. Swap the texture, get a new character. Near-zero runtime cost.

Setup is more involved:

1. Convert your sprite to an indexed format where each pixel stores a palette index in the red channel.
2. Build palette textures — 1×N pixel strips where pixel (0, i) is the color for index i.
3. Write a shader that reads the sprite's red channel as an index and samples the palette texture at that index.

You need tooling for step 1, but once it's in place, every artist workflow stays the same (draw in normal colors) and the conversion happens automatically on export.

Palette Design Rules

Not every sprite palette-swaps well. Design yours with swapping in mind and the technique becomes magic. Design yours naively and swaps look like crap.

Rule 1: Keep the Palette Small

The NES got 4 colors per palette. You don't need 4, but you should stay in the 4–16 color range. Why? Each additional color means more choices when building a variant. A 64-color palette requires 64 coordinated decisions to make a clean variant. A 6-color palette requires 6.

Indie games using 4–8 color palettes can generate dozens of clean variants without a design system breaking down. Games with bloated palettes struggle to produce even a single convincing swap.

Rule 2: Separate Luminance from Hue

The most common palette-swap mistake: changing colors without preserving lightness relationships. A character's shadow color should stay darker than its midtone, which should stay darker than its highlight. If you swap just the hue of each color without controlling luminance, you get weird visual inversions where shadows become lighter than highlights.

The fix: design your base palette as a luminance ramp. Pick your darkest, midtone, and lightest. Make sure variants follow the same ramp in a different hue.

Rule 3: Anchor With Black and White

Keep at least one very dark and one very light color that doesn't change between variants. Usually this is the outline (pure black or very dark) and highlights (pure white or cream).

Why: these anchors give your eye a stable reference. A character whose entire silhouette changes color looks like a different character. A character whose interior changes color but keeps the same black outline reads as a variant of the first character. That's exactly the perception you want.

Rule 4: Test at Small Scale

At 400% zoom in your editor, every variant looks fine. At the game's actual resolution — where the character might be 16 pixels tall — only the variants with strong silhouette contrast survive. Design your palettes to have good tonal range, not just good hue range. A pale yellow-green variant that looked fine in Aseprite might be indistinguishable from the original at 1× zoom.

Common Palette-Swap Patterns

Some patterns have been used so often they've become archetypes. Steal them shamelessly:

Elemental variants — Fire (red/orange), Ice (blue/white), Earth (brown/green), Lightning (yellow/purple). Every RPG ever.

Difficulty tiers — Green (easy), Blue (normal), Red (hard), Purple (elite), Gold (legendary). Diablo, Borderlands, Crypt of the NecroDancer.

Faction coloring — Red team vs blue team. Each faction gets a coordinated palette shift; everything else stays identical. Strategy games, team PvP.

Day/night cycles — Same tileset, palette swapped to shift color temperature. Warm oranges for day, cool blues for night, subtle reds at dusk. Stardew Valley, Terraria, Moonring.

Damage state — Flash the entire sprite white for 2 frames on hit (uniform-color palette swap). Nearly every action game does this. It's a palette swap at the frame level.

Player customization — Hair color, skin tone, armor tint. All palette swaps layered on top of a base character. Stardew, Rimworld, countless roguelikes.

Doing It Right: A Concrete Example

Let's build a classic. One goblin, four variants.

Step 1: Base Sprite + 6-Color Palette

Draw a goblin with the following palette:

• Dark outline (#1a0e0e)
• Skin shadow (#2d5a2d)
• Skin midtone (#4a8b3d)
• Skin highlight (#7bc85a)
• Cloth shadow (#5a3a1a)
• Cloth midtone (#8b6430)

Step 2: Variant Designs

Variant	Skin Palette	Cloth Palette
Goblin Scout	Original greens	Original browns
Goblin Warrior	Same greens	Blue-grays (#2a3a5a / #4a6b8b)
Goblin Shaman	Pale purples (#5a3a5a / #8b6b8b)	Red-golds (#6b3a1a / #b88b30)
Goblin Chief	Deep reds (#5a1a1a / #8b3a3a)	Dark purples (#3a1a3a / #6b3a6b)

Each variant keeps the dark outline color. Each variant keeps its luminance ramp. Each variant has a distinctive silhouette color that reads clearly at 16×16.

Step 3: Export Four Sheets

Drop the goblin's sprite sheet into the recolor tool, define each variant's palette, export each variant as its own sheet. That's it — four enemies, one original drawing.

Total time for all variants: about 10 minutes with a good tool. The same variants hand-drawn from scratch would take 4–6 hours minimum.

Advanced: Dynamic Palettes

Once you're comfortable with static swaps, the next level is dynamic. A few techniques:

Gradient Palettes

Instead of picking solid colors, pick a gradient along which the palette slides. A character that transitions from blue to purple to red as it gets angrier is just one sprite with an animated palette uniform.

Generative Variants

Procedural games need procedural palettes. Build a palette generator that picks a hue, derives an analogous or complementary hue, and assigns them to slot positions. Every run of the game, every enemy gets a unique palette. Used extensively in roguelikes and procedural platformers.

Palette Blending

Cross-fade between two palettes over a few frames to create smooth color transitions. Use this for team captures, power-ups, status effects, or weather shifts. Much smoother than an instant swap.

Tools for Palette Work

The ecosystem is rich in 2026:

• Lospec — thousands of curated palettes with downloadable files
• Aseprite — built-in palette management and color replace
• Coolors — generate new palettes from scratch or based on an image
• Our recolor tool — swap colors in-browser, export a variant sheet in seconds

A good palette workflow means picking your base palette once (or pulling it from Lospec), locking it in, and then reusing it for every character in your game. Consistency across your cast is what makes palette-swap variants look cohesive rather than arbitrary.

The Long View

Palette swapping is the oldest trick in pixel art — and also the one that's aged the best. The reasons it was invented (memory constraints) are gone. The reasons it stayed (visual communication, artist velocity, design clarity) are just as true now as in 1985.

The best palette-swapped games don't look cheap. They look deliberate. A shared silhouette with coordinated color variants is a stronger design language than unique art for every enemy. Players learn faster, silhouettes read clearer, and your production timeline shrinks without your game looking smaller.

One sprite. Many characters. It's not a shortcut — it's a design philosophy.

---

Photos via Unsplash — free for commercial use. Historical information via the NES palette swap documentation at Every NES Game and shader techniques from KoBeWi's Godot palette swap shader.