About

AVIF uses AV1 intra-frame coding with 10-bit or 12-bit color depth and supports millions of colors per pixel. GIF is constrained to a maximum of 256 indexed colors per frame with 1-bit transparency. Converting between these formats requires lossy color quantization: every pixel in the source must be mapped to the nearest entry in a reduced palette. Without proper dithering, this mapping produces visible banding artifacts in smooth gradients. This tool applies Median Cut quantization to build an optimal 256-color palette, then uses Floyd-Steinberg error diffusion to distribute quantization error across neighboring pixels. The result is a GIF file that preserves perceptual detail far better than naive nearest-color mapping.

Note: GIF is a legacy format. It does not support semi-transparency (alpha is binary on/off), cannot represent HDR content, and produces large files for photographic content. This tool approximates the source image assuming an sRGB color space and 8-bit output depth. Files above 4000 × 4000 pixels may require significant processing time due to the O(n log n) cost of palette generation across millions of pixels.

Formulas

The conversion pipeline applies two core algorithms sequentially. First, Median Cut quantization reduces the full RGB color space to 256 representative colors. Then LZW compression encodes the indexed pixel stream into the GIF binary format.

Color distance in RGB space (Euclidean):

d = √(r₁ − r₂)² + (g₁ − g₂)² + (b₁ − b₂)²

Floyd-Steinberg error diffusion distributes quantization error e to neighboring pixels:

e = original − quantized

pixel(x+1, y) += e × 716
pixel(x−1, y+1) += e × 316
pixel(x, y+1) += e × 516
pixel(x+1, y+1) += e × 116

LZW minimum code size for GIF starts at 8 bits (matching 256-color palette). The initial dictionary has 258 entries: 256 color indices + Clear Code (256) + EOI Code (257). Code width grows from 9 to 12 bits as the dictionary fills.

Where r, g, b are the red, green, blue channel values in range [0, 255]. e is the per-channel error vector. The diffusion kernel coefficients sum to 1 (7+3+5+116 = 1), ensuring no energy is created or destroyed during diffusion.

Reference Data

Property	AVIF	GIF
Year Introduced	2019	1987 (GIF89a: 1989)
Compression	AV1 Intra-frame (lossy/lossless)	LZW (lossless on indexed data)
Max Colors	16.7M+ (up to 12-bit depth)	256 per frame (indexed palette)
Bit Depth	8/10/12 bits per channel	8 bits per pixel (indexed)
Transparency	Full 8-bit alpha channel	1-bit (on/off per pixel)
Animation	Supported (AVIF sequence)	Supported (frame-based)
HDR Support	Yes (PQ, HLG transfer functions)	No
Color Space	sRGB, Display P3, BT.2020	sRGB only (implicit)
Typical Compression Ratio (Photo)	20:1 - 50:1	3:1 - 5:1
Lossless Mode	Yes	Yes (within 256-color limit)
MIME Type	`image/avif`	`image/gif`
File Signature (Magic Bytes)	`ftypavif` at offset 4	`GIF87a` or `GIF89a`
Max Dimensions	65536 × 65536	65535 × 65535
Browser Support (2024)	Chrome, Firefox, Safari 16.4+, Edge	Universal (all browsers)
ICC Profile	Embedded (NCLX / ICC)	Not supported
Metadata	EXIF, XMP via ISOBMFF	Comment extension only
Interlacing	Not applicable	Supported (4-pass)
Use Case	Web photos, HDR content	Simple graphics, logos, memes
Licensing	Royalty-free (AOM)	Patent-free (since 2004)

Frequently Asked Questions

GIF supports a maximum of 256 colors per frame, while AVIF can encode over 16 million. Smooth gradients in the source are forcibly mapped to a small palette, causing visible color steps. Enable the Floyd-Steinberg dithering option to mitigate this. Dithering introduces a fine noise pattern that simulates intermediate colors, reducing perceived banding at the cost of slightly larger file size.

AVIF uses AV1 intra-frame coding, which achieves compression ratios of 20:1 to 50:1 on photographic content. GIF's LZW compression works on indexed pixel data and typically achieves only 3:1 to 5:1. A 50 KB AVIF photo may produce a 300 - 800 KB GIF. For smaller outputs, reduce image dimensions before converting.

AVIF supports full 8-bit alpha (continuous transparency from 0 to 255). GIF only supports 1-bit transparency: each pixel is either fully opaque or fully transparent. This tool applies a threshold at α < 128 to classify pixels as transparent. Semi-transparent pixels above that threshold are composited onto a white background before quantization.

The browser decodes AVIF into its display color space (typically sRGB) before the Canvas API captures pixel data. HDR tone mapping and gamut compression are handled by the browser's rendering engine. The resulting GIF is always in sRGB with 8-bit precision. Colors outside the sRGB gamut in the original are clipped or tone-mapped during this process.

This tool converts single-frame (still) AVIF images. Animated AVIF sequences (AVIF with multiple frames in an ISOBMFF container) are decoded by the browser as a static image (first frame). Full animated sequence conversion requires parsing the ISOBMFF container and extracting each frame independently, which exceeds browser-native decoding capabilities.

Browser Canvas elements have memory limits that vary by device. Most desktop browsers support canvases up to approximately 16384 × 16384 pixels (268 megapixels). Mobile browsers often cap at 4096 × 4096. Images exceeding these limits may silently fail to render. This tool validates canvas allocation and reports an error if the browser cannot handle the source dimensions.