Has WebP Finally Won? The Unlikely Rise of a Web Image Format

One Post That Sparked a Format Migration

A developer posted on Hacker News with the title "I guess I'm using WebP now?" — a headline loaded with resignation and a hint of reluctant acceptance. Behind that tone lies a question that has long haunted web developers: how do you even choose an image format?

For years, JPEG and PNG dominated the web. JPEG handled lossy compression for photos; PNG covered graphics requiring transparency or sharp edges. WebP, Google's contender, promised smaller file sizes with comparable or better image quality — yet it spent years on the margins, held back by poor browser compatibility and inadequate tooling. That developer's "I guess I'm using WebP now" is a quiet signal that the landscape has shifted.

Why Developers Hesitated on WebP

The biggest obstacle WebP faced early on was ecosystem fragmentation. Safari didn't support it initially, and Firefox was slow to follow. That meant any developer who wanted to use WebP had to maintain a fallback — typically a <picture> element serving both WebP and JPEG/PNG versions, letting the browser pick. That dual-maintenance overhead was enough to make many teams walk away entirely.

Tooling lagged too. Photoshop offered no native WebP export. Command-line conversion required installing utilities like cwebp. Many CMS platforms and image hosting services didn't accept WebP uploads at all. These friction points stacked up, leaving WebP stuck in the awkward position of being "theoretically better, practically painful" for a long time.

The Turning Point: Universal Browser Support

What finally changed the game was broad browser compatibility. Once Safari joined the WebP camp, coverage across major browsers was essentially complete. Developers no longer had to maintain duplicate image assets for the sake of compatibility — they could commit to WebP without reservation.

With that barrier gone, WebP's technical advantages could finally shine:

• Smaller file sizes: At comparable quality, WebP is typically 25–35% smaller than JPEG, and outperforms PNG on lossless compression too.
• Lossy and lossless in one format: A single format handles both JPEG-style and PNG-style use cases.
• Transparency and animation support: WebP can replace transparent PNGs and bloated GIF animations alike.

For sites focused on page load speed and Core Web Vitals, these gains translate directly into better user experience and SEO rankings.

The "I Guess" Mentality

That "I guess" in the title is telling. It's not the enthusiastic embrace of exciting new technology — it's pragmatic, even a little passive. Developers aren't switching to WebP because it's cool. They're switching because all the reasons not to have quietly disappeared, and sticking with the old formats now feels harder to justify.

This is actually the classic pattern of technology adoption: a new standard rarely spreads overnight through sheer revolutionary appeal. More often, it wins by grinding down every excuse to avoid it. Once compatibility, tooling, documentation, and community practices all mature, the migration cost drops low enough that developers naturally go with the flow. WebP took exactly that path.

The Competition: AVIF Enters the Picture

Just as WebP found solid footing, a newer challenger arrived: AVIF. Based on the AV1 video codec, AVIF frequently achieves better compression than WebP with superior quality retention. The catch? Encoding is significantly slower, toolchain maturity still trails WebP, and browser support is still catching up.

AVIF (AV1 Image File Format) is essentially a static image format extracted from the AV1 video codec, developed by the Alliance for Open Media — with Netflix, Google, Mozilla, and others involved. Because AV1 was designed for efficient video streaming, its underlying algorithms handle complex textures and color gradients exceptionally well. At equivalent quality scores, AVIF often saves 20–50% in file size compared to WebP, with particularly strong visual performance at low bitrates.

However, AVIF's encoding computation is far heavier than WebP's. Generating a single AVIF image can require several times the CPU time, which is a meaningful cost burden for batch processing or real-time thumbnail generation. Much like WebP's early struggles, AVIF is still in the toolchain-completion phase — Squoosh and Cloudflare Images already support it, but native integration in every build tool and CMS plugin isn't there yet.

From this perspective, WebP currently occupies a sweet spot: advanced enough technically, mature enough in ecosystem, and broad enough in compatibility. For most projects, it's the safest default choice today. AVIF is more of an option for those chasing maximum compression — a good candidate for the top slot in a <picture> fallback chain.

Practical Advice for Developers

If you've been on the fence, now is genuinely a good time to switch to WebP. Some practical pointers:

• For new projects, default to WebP outright and skip the dual-asset maintenance burden.
• For performance-critical pages, use <picture> with AVIF as the first choice, WebP as the fallback, and JPEG as the final safety net.
• Use automated tooling (image optimization plugins in your build pipeline) for batch conversion — avoid manual processing.
• Look into your CDN or image hosting service. Many already support automatic format negotiation, serving the optimal format based on request headers.

Content Negotiation is the underlying mechanism that enables CDNs and servers to automatically return the best image format: the client declares supported MIME types in the HTTP Accept header (e.g., image/avif, image/webp, image/jpeg), and the server or CDN responds with the most appropriate format. The same URL can return different formats to different browsers. Major CDNs like Cloudflare, Fastly, and AWS CloudFront all support this — once enabled, it's completely transparent to developers. No HTML changes, no duplicate assets, format upgrades handled by infrastructure automatically. For projects with large libraries of legacy images, this is often the lowest-friction migration path available.

A format that spent years in limbo has quietly become the obvious default. That in itself is a perfect snapshot of how web technology evolves.