Three plugins dominate the "make my WordPress images smaller" conversation: Smush, ShortPixel, and EWWW Image Optimizer. They get recommended interchangeably, as if the only difference were the logo. They are not interchangeable. They make fundamentally different architectural choices about where compression happens, how you pay for it, and which next-gen formats you get. Pick wrong and you either overpay, hit a wall at scale, or quietly fail on your specific host.

This isn't a fabricated benchmark table with invented Lighthouse scores. Compression ratios depend entirely on your own images, so a single "X beats Y by 34%" number is close to meaningless. Instead, this is a comparison of the things that are actually fixed and verifiable, plus how to run a real benchmark on your own library at the end.

The one decision that splits these three: where does compression run?

This is the fork that matters most, and it's the thing most "best image plugin" lists skip.

EWWW Image Optimizer is the only one of the three that can compress images locally on your own server, for free, with no credit limits and no account. It shells out to standard binaries (jpegtran, optipng, pngquant, gifsicle, cwebp) installed on the host. Nothing leaves your server, there's no per-image meter, and a 50,000-image library costs exactly nothing to optimize. The catch is real, though: local mode relies on PHP's exec() and bundled binaries, and a lot of managed hosts (Kinsta, WP Engine, Pantheon, many cheap shared plans) disable exec() or lock down the filesystem. On those hosts EWWW's free local engine simply won't run, and you're pushed toward its paid cloud API anyway.

ShortPixel and Smush are cloud-first by design. Your images are uploaded to their servers, compressed, and sent back. That sidesteps the exec() problem entirely — they work on locked-down managed hosts where EWWW's free mode dies — but it means every optimized image counts against a quota, and your media passes through a third party (a real, if minor, privacy consideration for some sites).

So the very first question isn't "which is best," it's "does my host let me run binaries?" If yes and you're cost-sensitive, EWWW local is in a category of one. If no, you're choosing between ShortPixel and Smush on other grounds.

Pricing models, which are not the same shape

Comparing prices here is genuinely confusing because the three use different meters.

EWWW — Free and unlimited for local optimization. Its paid layer is the Easy IO CDN (image resizing, delivery, and AVIF) starting around $5/month, plus an optional cloud compression API for hosts that can't run local binaries. You only pay if you need the CDN or can't go local.
ShortPixel — Credit-based. Roughly 100 free credits per month (one credit ≈ one image, and each WebP/AVIF copy can count too). Beyond that you buy credits: one-time packs (e.g. ~$19.99 for 30,000 credits that don't expire) or monthly subscriptions from around $9.99/month, including an unlimited "All You Can Optimize" tier. Excellent for a one-off bulk pass on a big back-catalog, because one-time credits don't expire.
Smush — Freemium with a generous-feeling free tier that hides sharp edges: the free version skips any image over 5 MB and only does 50 images per bulk run, so a large library means clicking "resume" repeatedly. WebP/AVIF conversion, lossy compression, full-size compression (up to 256 MB), and the CDN all live in Smush Pro, which runs about $60/year at list price (often discounted). Smush Pro is really sold as part of the broader WPMU DEV membership.

The practical read: for a high-volume one-time optimization, ShortPixel's non-expiring credit packs are the cheapest sane option. For ongoing free optimization on a capable host, EWWW local wins outright. Smush's free tier is fine for small sites but its real value is locked in Pro.

Formats: WebP is table stakes, AVIF is the 2026 differentiator

In 2026, serving next-gen formats is no longer optional if you care about Core Web Vitals — AVIF in particular routinely lands files 30–50% smaller than equivalent-quality JPEG, which directly helps your Largest Contentful Paint (you want LCP under 2.5s). Here's where the three diverge:

ShortPixel converts to both WebP and AVIF, and notably offers AVIF generation across its tiers — the most accessible AVIF of the three.
EWWW does WebP locally for free (via cwebp), but AVIF is gated behind the paid Easy IO CDN — there's no free local AVIF.
Smush keeps both WebP and AVIF conversion in Pro; the free version does neither.

If "free AVIF" is on your wishlist, none of them fully deliver it: ShortPixel needs credits, EWWW needs Easy IO, Smush needs Pro. The honest answer is that AVIF generation costs real CPU or money somewhere, and these plugins all reflect that.

Compression aggressiveness and reputation

Stated as general behavior rather than a measured stat: Smush historically leans conservative — its free compression is lossless-ish and gentle, which is great for fidelity but leaves bytes on the table unless you enable Pro's lossy mode. ShortPixel is the aggressive one, with a well-regarded "Glossy" mode that gets close to lossless visually while cutting far more weight, plus a fully lossy mode for maximum savings. EWWW sits in between and is highly configurable, but its best results often require enabling its paid pixel-perfect or cloud modes. If your priority is the smallest files at acceptable quality, ShortPixel's Glossy is the setting most practitioners reach for first.

Ecosystem and support

Scale matters when you're troubleshooting at 11pm. Smush is the giant by install base (millions of active installs, backed by WPMU DEV), so tutorials and forum answers are everywhere. EWWW is also a veteran with 1M+ installs and unusually responsive developer support. ShortPixel is smaller but has a loyal, technically engaged user base and strong documentation. None of the three will leave you stranded, but Smush has the deepest pool of generic "how do I…" answers.

How to actually benchmark this on your own site

Because real savings depend on your images, run a 30-minute test instead of trusting anyone's table — including this one:

Build a representative sample. Copy 15–20 real images from your media library — a mix of hero photos, screenshots, PNG logos, and product shots. That mix is what determines your results.
Optimize the same set with each plugin on a staging copy, using comparable settings (e.g. lossy/Glossy on each), and record the output file sizes. Compare total bytes saved, not percentages on a single image.
Eyeball quality at 100%. Aggressive compression can introduce banding in gradients and halos around text. Check your logos and any image with flat color.
Measure the page, not just the file. Run the optimized page through PageSpeed Insights and watch the LCP element — that's the number Google's Core Web Vitals actually grade. A 40% smaller hero image that is the LCP element moves the needle far more than shrinking a footer icon.
Confirm next-gen delivery. Open DevTools, reload, and verify images are served as .webp or .avif with correct fallbacks for older browsers.

The honest verdict

There's no universal winner, only a best fit:

Choose EWWW if your host allows local binaries and you want unlimited free compression with nothing leaving your server — the budget and privacy pick, provided you don't need free AVIF.
Choose ShortPixel if you want the most aggressive compression, the easiest AVIF, and pay-as-you-go credits that don't expire — ideal for a big one-time cleanup or a media-heavy site that hates subscriptions.
Choose Smush if you're already in the WPMU DEV ecosystem, want a polished UI with a gentle learning curve, and are willing to pay for Pro to unlock the features (WebP/AVIF, lossy, CDN) that actually move performance.

Whatever you pick, set up automatic conversion on new uploads so this becomes a one-time decision rather than a recurring chore — and always keep originals backed up before your first bulk run.

Smush vs ShortPixel vs EWWW: Image Compression Benchmark