Back to Blog
·9 min read·quickpix-image-compressor

WebP vs AVIF vs JPEG on Mac — when to use which (with real file-size numbers)

Three modern image formats, three different trade-offs. Here's a real-world test on Mac, with concrete recommendations for web, design, and archival use.

Every few years the "best web image format" debate restarts. In 2026 the contenders worth taking seriously on Mac are JPEG (the universal default), WebP (Google's 2010 alternative, now nearly universally supported), and AVIF (the AV1-derived 2019 challenger). Each one wins for a different reason.

This post is what I learned running the same images through all three formats with QuickPix and macOS's built-in sips, and what I'd recommend for the specific situations Mac users actually face.

Three formats in one sentence each

  • JPEG: The 1992 codec everything understands. Mature, fast, lossy, and your floor.
  • WebP: Google's modernization of JPEG. Same lossy/lossless trade-offs, smaller files at the same quality.
  • AVIF: Encoded with the AV1 codec. Smallest files at the same quality, but slow to encode and not universally supported.

If you only remember three numbers from this post: a representative phone photo compresses to ~720 KB as JPEG, ~510 KB as WebP, and ~370 KB as AVIF at visually-equivalent quality. That's roughly the math you can expect on most modern web imagery.

A real test (one image, three formats)

I took a 12 MP HEIC photo straight from an iPhone 15 (3.8 MB at source) and compressed it three ways targeting "visually identical to original on a Retina display":

| Format | File size | % of source | Encoder | Wall time on M2 | |---|---|---|---|---| | Source HEIC | 3.8 MB | 100% | — | — | | JPEG quality 80 | 720 KB | 19% | sips | 0.2s | | WebP quality 80 | 510 KB | 13% | sips | 0.4s | | AVIF quality 60 | 370 KB | 10% | QuickPix (libavif) | 2.1s |

AVIF wins on bytes; JPEG wins on speed; WebP is the pragmatic middle ground.

The encode-time gap matters more than it sounds. On a single image, 2 seconds vs 0.2 seconds is fine. On a folder of 200 images for a product launch, that's 7 minutes vs 40 seconds. AVIF batch encoding is something you start before a coffee break.

Browser and OS support in 2026

The 2018 "AVIF isn't supported" complaint is mostly resolved. Current state:

| Format | Safari | Chrome | Firefox | iOS (Save Image) | macOS Preview | |---|---|---|---|---|---| | JPEG | ✅ | ✅ | ✅ | ✅ | ✅ | | WebP | ✅ (14+) | ✅ | ✅ | ✅ | ✅ | | AVIF | ✅ (16+) | ✅ | ✅ | ✅ (iOS 16+) | ✅ |

Caveat for AVIF: third-party tools (image editors, CMSs, email clients, older Mac apps like Keynote 11.x) are inconsistent. Photoshop reads AVIF since 2023, but plenty of in-the-wild tools you don't control still don't. If your image will land somewhere you don't manage, WebP is the safer pick.

When to use which — concrete recommendations

Use JPEG when…

  • You don't control where the image ends up (forums, comments, emails, old CMSs)
  • Speed of encoding matters more than file size (batch of 1000+ images on a deadline)
  • You're sending photos to a non-technical recipient who'll right-click → save → email
  • The image will be opened in an app older than ~2022

JPEG is still the right answer surprisingly often. Don't switch defaults without a reason.

Use WebP when…

  • You control the surface (your blog, your website, your design system)
  • You want roughly 30% smaller files than JPEG with negligible quality loss
  • You need decent universal support in 2026 but don't want to deal with AVIF's encoder quirks
  • You ship for Apple ecosystem (Safari 14+ has full support)

For most websites in 2026, WebP is the right default. It's a near-strict improvement over JPEG with nothing to think about.

Use AVIF when…

  • You ship a small number of high-traffic images where every kilobyte matters (homepage hero, OG cards)
  • You can afford the encode-time overhead (CI step, not user-facing)
  • Your CDN can auto-serve a fallback when AVIF isn't supported (Cloudflare Images, ImageKit, etc.)
  • You're archiving family photos where storage savings compound over decades

For most operators, AVIF is a "secondary format" — generate it for browsers that support it via a <picture> tag, fall back to WebP or JPEG.

How to convert on Mac

QuickTime / Preview won't help

macOS Preview can read all three formats, but it can only export to JPEG, PNG, TIFF, and HEIC. WebP and AVIF export is missing as of macOS Sequoia. The system frameworks support these formats — Apple just hasn't exposed them in Preview.

sips for WebP

```bash

WebP at quality 80

sips -s format webp -s formatOptions 80 input.jpg --out output.webp

Lossless WebP

sips -s format webp -s formatOptions 100 input.jpg --out output.webp ```

WebP output via sips ships in macOS Sonoma and later. Reliable for batch jobs.

AVIF on the command line

sips doesn't currently output AVIF in macOS Sequoia (May 2026 status). The mainstream options:

```bash

Install libavif via Homebrew

brew install libavif

Encode a JPEG to AVIF at quality 60 (perceptual quality, lower = smaller)

avifenc --min 0 --max 63 --speed 6 -q 60 input.jpg output.avif

Batch a folder

for f in *.jpg; do avifenc -q 60 --speed 6 "$f" "${f%.jpg}.avif" done ```

The --speed 6 flag is the sweet spot. --speed 0 is slowest (highest quality at a given size) — about 20× slower; --speed 10 is fastest but loses some quality advantage.

QuickPix for batch conversion

If you don't want to manage two CLIs (sips + avifenc) and you're converting a folder a week:

1. Drop folder into QuickPix 2. Pick output format (JPEG, WebP, or AVIF) 3. Pick quality preset 4. Save

QuickPix uses sips for JPEG/WebP and bundles libavif for AVIF output. Folder-watch (Pro) auto-converts as new images arrive — useful for design teams who get assets via Dropbox or Slack.

Other formats worth knowing about

A few formats that come up but I'd think hard about before using:

  • HEIC: Apple's modern format. Excellent compression. Use it for personal photo archival on Apple devices. Avoid for the open web (Android browsers don't natively render it). HEIC-to-WebP/AVIF is a common one-step pipeline.
  • JPEG XL: Technically the best image format on paper — smallest files, lossless mode, animation. But Chromium removed support in 2023 and hasn't come back. As of 2026, JPEG XL is a Safari/Firefox-only bet, not viable for general web.
  • PNG: Use for screenshots, UI mockups, anywhere with crisp edges or alpha. Don't use for photos — JPEG/WebP/AVIF crush PNG on file size for natural images.
  • GIF: Don't. Use MP4 or animated WebP. GIF is a 1989 format optimized for terminals with 256 colors. Modern alternatives are 10x smaller and look better.

Best-quality recipes

If you want concrete starting parameters, here's what I use for common cases:

```bash

Hero image for a marketing page (1920×1080, photo)

WebP at quality 82 — visually indistinguishable at typical viewing distance

sips -s format webp -s formatOptions 82 -Z 1920 hero.jpg --out hero.webp

Blog post inline images (max 1200px wide, photo)

sips -s format webp -s formatOptions 78 -Z 1200 photo.jpg --out photo.webp

Same image as AVIF fallback for top-of-page

avifenc -q 55 --speed 6 -j 4 hero.jpg hero.avif

Screenshot for documentation (PNG → smaller PNG)

sips -s format png -Z 1200 screenshot.png --out _web/screenshot.png ```

The <picture> element pattern

Once you have multiple formats, your HTML serves the smallest one each browser supports:

``html <picture> <source srcset="hero.avif" type="image/avif"> <source srcset="hero.webp" type="image/webp"> <img src="hero.jpg" alt="Hero image"> </picture> ``

Browsers pick the first supported source. Safari 16+ gets AVIF, Safari 14-15 falls to WebP, anything older falls to JPEG. This is the canonical "ship modern formats safely" pattern.

If you use a static site generator or CMS, look for an "auto-generate AVIF/WebP variants" plugin — Next.js has this built into the next/image component, Hugo via image processing, Jekyll via the jekyll-picture-tag gem.

What I do

For most things I ship on obelisk.club: WebP at quality 80, single format. I don't generate AVIF because the encoding time isn't worth the bytes for a low-traffic site. If I were running an e-commerce homepage seen by millions, AVIF + <picture> fallback would be worth the CI cost.

For personal photo archival: HEIC (iCloud) plus a periodic WebP mirror to a NAS for non-Apple-device access.

For one-off uploads (Discord, Slack, email): JPEG at quality 85, because that's what everything still understands and the file size is fine for most use.

Closing

Stop assuming AVIF wins by default. The format math depends on where the image is going. WebP is the boring right answer for most web work; AVIF is worth it for high-traffic critical images; JPEG is still the right answer when the destination is unknown.

If you compress images weekly, QuickPix wraps all three formats into one Mac-native app — drop folder, pick format and quality, save. Folder watching for design teams in Pro. Free tier handles unlimited single-format batches.

For the deeper dive into sips itself, macOS sips command — the complete guide covers everything Apple's CLI tool can do.

FAQ

Is AVIF better than WebP in 2026?

For file size: yes, typically 25-30% smaller than WebP at the same visual quality. For practicality: depends on your tools. AVIF is universally supported in browsers (Safari 16+, Chrome, Firefox) but third-party image editors, design tools, and email clients still lag. WebP is the safer default; use AVIF for high-impact images where you control the surface.

Does macOS support AVIF natively?

macOS Ventura and later can read AVIF in Preview, Photos, and Quick Look. Writing AVIF requires a third-party encoder (libavif, ImageMagick, or a GUI like QuickPix) — Apple's sips doesn't currently export AVIF as of Sequoia.

Should I convert all my JPEGs to WebP?

If they're hosted on a website you control and the site doesn't already auto-serve WebP — yes, you'll save 25-35% bandwidth with no visible quality loss. If they're personal photos in iCloud or local archives, leave them as JPEG/HEIC — the bandwidth savings don't apply and the format conversion is lossy.

What quality level should I use for WebP?

Quality 75-85 covers 95% of use cases. Quality 80 is the most common default and produces visually indistinguishable results from the JPEG source at typical viewing distances. For hero/marketing images where every byte matters, drop to 70-75. For high-detail product photography, go up to 85-90. Above 90 the file-size cost outweighs the visible improvement.

Will Apple devices show WebP and AVIF images?

Yes. Safari has supported WebP since 14 (2020) and AVIF since 16 (2022). iOS Photos, macOS Photos, and Preview all display both formats. Mail, Messages, and Notes also render them correctly. The remaining edge case is third-party Mac apps that haven't updated their image-handling code in years — most modern apps are fine.

#mac#image-formats#webp#avif#jpeg#quickpix

Written by

Peter Zhang

Building local-first Mac & iOS productivity apps at Obelisk Club.