What exactly gets randomized, the pixels or the colors?

Neither pixel positions nor which index each pixel uses ever change. Only the color table itself is shuffled, so index 42 might now render as whatever color used to be index 190. The shapes in the animation stay perfectly intact, only their colors scramble.

Is the shuffle the same across every frame?

Yes, one shuffle is generated per run and reused for every frame, so the whole animation gets one consistent 'corrupted' color scheme rather than flickering between different scrambles each frame.

Why does this use a cryptographic random number generator instead of Math.random()?

The shuffle is built with crypto.getRandomValues()-backed rejection sampling (the same helper this site's random-tools category uses for anything where a predictable PRNG would be a weakness), which avoids the subtle sequence patterns a plain Math.random() shuffle can produce.

What happens to transparent pixels?

They're left alone; only pixels that map to one of the 216 opaque color slots get remapped, transparency is never reshuffled into a color.

GIF Color Index Randomizer - Corrupted Colors Glitch Effect

Overview

Introduction

This tool produces a classic 'corrupted GIF' glitch look by scrambling the shared color table this category's encoder uses, entirely in your browser.

Unlike effects that move or duplicate pixels, everything here stays exactly where it was; only which color each index displays as gets shuffled.

What Is GIF Color Index Randomizer?

A client-side glitch-effect tool that generates a random permutation of this category's fixed 216-color palette, then remaps every pixel's color according to that shuffled table rather than its original one.

It's the GIF equivalent of a corrupted palette table in a classic indexed-color image: the shapes are all correct, but the colors are wrong in a consistent, deterministic-once-shuffled way.

How GIF Color Index Randomizer Works

The shared palette's 216 color slots are shuffled once using a Fisher-Yates shuffle driven by a cryptographically random number generator, producing a one-to-one remapping from old slot to new slot.

Every frame's pixels are then passed through the same quantization function the shared encoder uses to find their original slot, and recolored with whatever color that slot's shuffled counterpart now holds, before all frames are re-encoded.

When To Use GIF Color Index Randomizer

Use it to generate a retro 'broken palette' glitch effect for a GIF, evoking corrupted 8-bit or indexed-color imagery.

It's also a fun way to see how visually different a GIF looks when only its color table (not its actual content) is scrambled.

Often used alongside GIF Color Index Extractor, GIF Color Changer and GIF Quantizer.

Features

Advantages

Keeps every shape, edge, and animation timing perfectly intact, isolating the glitch purely to color.
Uses a cryptographically random shuffle rather than a predictable PRNG, so results genuinely vary between runs.
Applies one consistent shuffle across the whole animation instead of flickering per frame.

Limitations

The effect isn't reproducible with a seed; each run generates a fresh random shuffle rather than a repeatable one.
Because it works through the shared 216-color quantization step, two visually distinct source colors that map to the same palette slot will always end up the same corrupted color.

Examples

Corrupting a simple flat-color animation

Input

A red-and-white looping icon GIF

Output

The same shapes and timing, now rendered in two unrelated shuffled colors (e.g. teal and violet)

The red and white regions each mapped to a specific palette slot; the shuffle reassigned those slots to different colors.

Best Practices & Notes

Best Practices

Re-run the tool if the first shuffle's colors are too similar to the original; each run produces a fresh random result.
Combine with GIF Color Index Extractor first to understand how many distinct slots your source GIF actually uses, which hints at how varied the glitch will look.
Use GIF Color Changer's channel-remap mode instead if you want a repeatable, non-random 'wrong colors' effect.

Developer Notes

The permutation is generated with this codebase's shared `fisherYatesShuffle` helper from the random-tools category, given a `rand()` function backed by `secureRandomInt` (crypto.getRandomValues() with rejection sampling) rather than `Math.random()`, and applied identically to every frame by building one remapped 216-color lookup table up front.

GIF Color Index Randomizer Use Cases

Creating a retro corrupted-palette glitch effect for a GIF meant to look broken or unstable
Generating quick alternate colorways of a simple animation by re-running the shuffle
Demonstrating how indexed-color images depend on their color table separately from their pixel data

Common Mistakes

Expecting the shuffle to be reproducible between runs; it's intentionally fresh random each time.
Assuming pixel positions or shapes change; only the color table is ever touched.

Tips

This pairs well with GIF Ditherer applied first, since a dithered source gives the shuffle more distinct slots to work with.
If the result looks too chaotic, GIF Color Reducer first (to fewer colors) makes the eventual shuffle easier to read.

GIF Color Index Randomizer