Lossy or lossless: which compression should I use for web images?

Use lossy (JPG, WebP, AVIF) for photographs — the human eye barely notices the difference at quality 80–85, and file sizes are 5–20× smaller. Use lossless (PNG, WebP-lossless) for screenshots, UI mockups, logos and anything with sharp edges or text — lossy creates ugly artifacts around boundaries.

Does conversion preserve EXIF metadata (camera, GPS, date)?

It depends on the tool: ImageMagick and FFmpeg copy EXIF by default, while cwebp drops it unless you pass -metadata all . KaijuConverter strips metadata server-side after conversion to protect your privacy — if you need to keep camera or GPS data, use a desktop tool you control.

Lossy or lossless: which compression should I use for web images?

Use lossy (JPG, WebP, AVIF) for photographs — the human eye barely notices the difference at quality 80–85, and file sizes are 5–20× smaller. Use lossless (PNG, WebP-lossless) for screenshots, UI mockups, logos and anything with sharp edges or text — lossy creates ugly artifacts around boundaries.

Does conversion preserve EXIF metadata (camera, GPS, date)?

It depends on the tool: ImageMagick and FFmpeg copy EXIF by default, while cwebp drops it unless you pass -metadata all . KaijuConverter strips metadata server-side after conversion to protect your privacy — if you need to keep camera or GPS data, use a desktop tool you control.

Guide

GIF Format Deep Dive: How a 1987 Format Still Dominates the Web

PC By Pablo Cirre • Updated May 7, 2026

GIF Format Deep Dive: How a 1987 Format Still Dominates the Web

The Graphics Interchange Format (GIF) was developed by CompuServe and introduced in 1987, making it one of the oldest image formats still in active use. Despite its technical limitations — most notably a 256-color palette and lossy-for-photographic-content LZW compression — GIF remains ubiquitous for animations, memes, and short looping clips. Understanding how GIF actually works explains both its longevity and its well-documented shortcomings.

The GIF Specification: 87a and 89a

GIF has two versions:

GIF87a (1987): Static images only. Supports interlacing (progressive rendering from top to bottom in 4 passes).
GIF89a (1989): Adds animation (multiple frames with per-frame delay), transparency (one color index designated transparent), comment extensions, and plain text extensions. All modern GIF animations use 89a.

The file structure of a GIF89a:

Header               "GIF89a"
Logical Screen Descriptor
  Width × Height
  Global Color Table Flag
  Color Resolution
  Sort Flag
  Background Color Index
  Pixel Aspect Ratio
Global Color Table    up to 256 RGB entries (3 bytes each)

[Repeated for each frame:]
  Graphic Control Extension
    Disposal Method  (keep / overwrite / restore to background / restore to previous)
    Delay Time       (in 1/100ths of a second)
    Transparent Flag + Transparent Color Index
  Image Descriptor
    Position (left, top), Dimensions
    Local Color Table Flag (can override global palette per-frame)
  Image Data         LZW-compressed pixel indices

Application Extension (NETSCAPE 2.0)
  Loop Count         (0 = infinite loop)

Trailer              0x3B

The 256-Color Limit and LZW Compression

The 256-color constraint is fundamental: each pixel is stored as an 8-bit index into the color table (0–255). For photographic images, this causes color banding — smooth gradients degrade into visible steps. Dithering algorithms (Floyd-Steinberg, pattern, Bayer) can reduce banding by mixing adjacent pixels of different colors to simulate intermediate tones.

LZW (Lempel-Ziv-Welch) compression is applied to the stream of color indices:

Works well for images with large horizontal runs of identical colors (icons, line art, pixel art)
Performs poorly on photographic content with high color variation
A typical photo GIF is 3–10× larger than the equivalent JPEG at comparable visual quality

LZW was patent-encumbered (Unisys held the patent until 2003). This patent dispute was one motivation for creating the PNG format.

Animation Mechanics

GIF animation works by specifying multiple image frames, each with:

A delay time (in centiseconds — 1/100ths of a second; minimum practical delay is ~2 cs = 50fps, though browsers typically cap at ~10 fps for delays under 2 cs)
A disposal method determining what happens to the frame after display
An optional local color table allowing different 256-color palettes per frame

Disposal methods:

Value	Name	Behavior
0	Do not dispose	Leave frame in place (next frame composited on top)
1	Do not dispose	Same as 0 (explicit)
2	Restore to background	Replace frame area with background color
3	Restore to previous	Restore to state before frame was drawn

The NETSCAPE 2.0 Application Extension added the loop count — this is a de facto standard, not part of the official GIF89a specification. Setting loop count to 0 causes infinite looping.

Creating Optimized GIFs

ffmpeg (video to GIF)

# Basic conversion
ffmpeg -i input.mp4 -vf "fps=15,scale=480:-1" output.gif

# High-quality with custom palette (recommended)
ffmpeg -i input.mp4 \
  -vf "fps=15,scale=480:-1:flags=lanczos,palettegen=stats_mode=diff" \
  palette.png

ffmpeg -i input.mp4 -i palette.png \
  -filter_complex "fps=15,scale=480:-1:flags=lanczos[x];[x][1:v]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle" \
  output.gif

The two-pass palette approach generates a palette optimized for the actual content rather than a generic 256-color palette, dramatically reducing color banding.

gifsicle (optimization and manipulation)

# Optimize GIF (reduce file size)
gifsicle --optimize=3 --colors 256 input.gif -o output.gif

# Change frame delay
gifsicle --delay 5 input.gif -o output.gif

# Extract frames
gifsicle --explode input.gif

# Combine frames into animation
gifsicle --delay 10 --loop frame*.gif > animation.gif

The Transparency Model

GIF supports binary transparency — a single color index is designated transparent. This means edges cannot be anti-aliased (jagged edges are visible against non-white backgrounds), and there are no intermediate alpha values (0 or 100% opacity only).

This is GIF's most significant limitation compared to PNG (8-bit alpha channel) and WebP (full alpha channel with smooth anti-aliasing).

Workaround: Match the GIF's matte color to the background color it will be displayed against — browsers won't expose the jagged edges if the matte matches the background.

Why GIF Persists Despite Better Alternatives

Feature	GIF	APNG	WebP	AVIF
Animation	✅	✅	✅	✅
Lossless compression	✅ (LZW)	✅ (PNG)	✅	✅
Lossy animation	❌	❌	✅	✅
Full alpha transparency	❌ (1-bit)	✅	✅	✅
Browser support	✅ 100%	✅ 97%+	✅ 97%+	✅ 95%+
Social media support	✅ Universal	Limited	Growing	Limited
Platform convention	✅ "Share a GIF"	❌	❌	❌

The answer is social convention and platform lock-in. Twitter, Reddit, Discord, Slack, Tenor, Giphy all accept GIF as the shorthand for "animated image." The format has a cultural identity that technical superiority alone cannot displace.

File Size Reduction Strategies

Reduce frame rate: 12–15 fps instead of 24–30 is imperceptible for most content
Reduce dimensions: halving width/height reduces pixels by 75%
Limit unique colors: fewer colors = smaller palette = better LZW compression
Optimize disposal: use Do not dispose for static backgrounds (only diff areas change)
Lossy GIF compression: gifsicle with --lossy=30 introduces LZW-compatible lossy artifacts that reduce size 30–60% with minimal visible quality loss
Convert to WebP or MP4: for files where GIF is used purely for animation (no GIF-specific platform requirement), WebP animated or MP4 (muted, autoplay, loop) is 3–10× smaller

When Not to Use GIF

Photographs: use JPEG or WebP
Images needing smooth alpha: use PNG or WebP
Long animations: use MP4 (a 10-second GIF at 15fps can easily exceed 10MB; the equivalent MP4 is under 500KB)
High-color illustrations: use PNG or WebP lossless
Any modern platform that accepts WebP/AVIF: use those formats

Summary

GIF is a technically obsolete format kept alive by cultural inertia and platform compatibility. Its 256-color limitation, 1-bit transparency, and LZW compression make it poorly suited for photographic content and long animations. For new content, prefer WebP animated, AVIF, or MP4 for animations, and PNG/WebP for static images. But when a platform explicitly requires GIF — social media sharing, messaging apps, reaction image culture — understanding GIF's internals lets you create the smallest possible files with the best achievable quality.

Related conversions

Most teams that read this guide convert images in one of these directions:

Related conversions

Put what you just learned into practice — convert your files now in seconds, free and without registration.

Convert →

Convert →

Convert →

Convert →

Convert →

Convert →

Frequently Asked Questions

GIF uses 8 bits per pixel, which can represent 2^8 = 256 different values. Each value is an index into a color table (palette) of up to 256 RGB entries. This was a reasonable limit in 1987 when RAM was expensive and most displays were limited to 16 or 256 colors. The LZW compression algorithm works on these indices rather than raw pixel data, making it efficient for low-color graphics but poor for photographs.

Use <strong>lossy</strong> (JPG, WebP, AVIF) for photographs — the human eye barely notices the difference at quality 80–85, and file sizes are 5–20× smaller. Use <strong>lossless</strong> (PNG, WebP-lossless) for screenshots, UI mockups, logos and anything with sharp edges or text — lossy creates ugly artifacts around boundaries.

Use ffmpeg with a two-pass palette approach for best quality: first generate an optimized palette with palettegen=stats_mode=diff, then use paletteuse with dithering. Reduce frame rate (12-15 fps) and dimensions (480px wide max) to control file size. For files over 2MB, consider using MP4 with autoplay+loop+muted instead — it will be 5-10x smaller with better quality.

Use ffmpeg com a two-pass palette approach para melhor qualidade: first generate an optimized palette com palettegen=stats_mode=diff, then usar paletteuse com dithering. Reduce frame rate (12-15 fps) e dimensions (480px wide max) to control tamanho do arquivo. para arquivos over 2MB, consider usando MP4 com autoplay+loop+muted instead — it will be 5-10x smaller com better quality.

Use ffmpeg mit a two-pass palette approach für beste Qualität: first generate an optimized palette mit palettegen=stats_mode=diff, then verwenden paletteuse mit dithering. Reduce frame rate (12-15 fps) und dimensions (480px wide max) to control Dateigröße. für Dateien over 2MB, consider using MP4 mit autoplay+loop+muted instead — it will be 5-10x smaller mit better quality.

Use ffmpeg con a two-pass palette approach para mejor calidad: first generate an optimized palette con palettegen=stats_mode=diff, then usar paletteuse con dithering. Reduce frame rate (12-15 fps) y dimensions (480px wide max) to control tamaño de archivo. para archivos over 2MB, consider using MP4 con autoplay+loop+muted instead — it will be 5-10x smaller con better quality.

For new projects in 2026, WebP is supported by all modern browsers (95%+ of traffic) and saves 25–35% over JPG at the same visual quality. AVIF is even more efficient (40–50% smaller) but encoding is slower and Safari support is recent. Use WebP as the default and AVIF as the progressive enhancement via <code><picture></code> with JPG fallback.

GIF supports binary (1-bit) transparency: one specific color index is designated as transparent, and every pixel is either 100% opaque or 100% transparent. This causes jagged edges on curved shapes. PNG supports full 8-bit alpha channel transparency where each pixel can have 256 levels of opacity (0-255), enabling smooth anti-aliased edges and semi-transparent effects that GIF cannot achieve.

GIF suporta binary (1-bit) transparência: one specific color index is designated as transparente, e every pixel is either 100% opaque ou 100% transparente. This causes jagged edges on curved shapes. PNG suporta full 8-bit alpha channel transparência where each pixel can have 256 levels of opacity (0-255), enabling smooth anti-aliased edges e semi-transparent effects that GIF cannot achieve.

GIF unterstützt binary (1-bit) Transparenz: one specific color index is designated as transparent, und every pixel is either 100% opaque oder 100% transparent. This causes jagged edges on curved shapes. PNG unterstützt full 8-bit alpha channel Transparenz where each pixel can have 256 levels von opacity (0-255), enabling smooth anti-aliased edges und semi-transparent effects that GIF cannot achieve.

GIF soporta binary (1-bit) transparencia: one specific color index is designated as transparente, y every pixel is either 100% opaque o 100% transparente. This causes jagged edges on curved shapes. PNG soporta full 8-bit alpha channel transparencia where each pixel can have 256 levels de opacity (0-255), enabling smooth anti-aliased edges y semi-transparent effects that GIF cannot achieve.

It depends on the tool: ImageMagick and FFmpeg copy EXIF by default, while cwebp drops it unless you pass <code>-metadata all</code>. KaijuConverter strips metadata server-side after conversion to protect your privacy — if you need to keep camera or GPS data, use a desktop tool you control.

The loop count is stored in a NETSCAPE 2.0 Application Extension block inside the GIF file. A loop count of 0 means infinite looping. A loop count of 1 means play once. A loop count of N means play N times. If the NETSCAPE extension is absent, most browsers play the animation once. Tools like gifsicle can set the loop count: gifsicle --loop=0 input.gif -o output.gif for infinite looping.

The loop count is stored em um NETSCAPE 2.0 aplicativo Extension block inside the GIF file. A loop count of 0 means infinite looping. A loop count of 1 means reproduzir once. A loop count of N means reproduzir N times. If the NETSCAPE extension is absent, most browsers reproduzir the animation once. ferramentas like gifsicle can set the loop count: gifsicle --loop=0 input.gif -o output.gif para infinite looping.

The loop count is stored in einem NETSCAPE 2.0 Anwendung Extension block inside the GIF file. A loop count von 0 means infinite looping. A loop count von 1 means abspielen once. A loop count von N means abspielen N times. If the NETSCAPE extension is absent, most browsers abspielen the animation once. Werkzeuge like gifsicle can set the loop count: gifsicle --loop=0 input.gif -o output.gif für infinite looping.

The loop count is stored en un NETSCAPE 2.0 aplicación Extension block inside the GIF file. A loop count de 0 means infinite looping. A loop count de 1 means reproducir once. A loop count de N means reproducir N times. If the NETSCAPE extension is absent, most browsers reproducir the animation once. herramientas like gifsicle can set the loop count: gifsicle --loop=0 input.gif -o output.gif para infinite looping.

Three common causes: (1) ICC color profiles dropped during conversion shift colors slightly; (2) chroma subsampling (4:2:0) reduces color accuracy in lossy JPG/WebP; (3) the new format may not support all features of the original (e.g. PNG → JPG drops transparency to white). For pixel-perfect results stick to lossless formats and preserve color profiles explicitly.