ImReso: Unlimited Target-Size Image Compressor

ImReso is a target-size, free bulk image compressor. It resizes and converts your photos and images to exact pixel dimensions or a specific file size, right in your browser — instantly. Free, unlimited and 100% privacy-first: the encoding runs on your own device and nothing is ever uploaded. Need 50 KB or 1000px? No problem.

Most plugins in this space hand your files to a third-party server or an external API. ImReso is different — client-side image compression, so your originals never leave your site, with no API key, no per-file cost, no monthly cap and no bulk-job timeout, even on the cheapest shared hosting.

Give it a size ceiling in KB and each upload is encoded to land under it automatically — no fiddling with a quality slider. ImReso reads JPEG, PNG, WebP, AVIF, HEIC/HEIF, TIFF and BMP, and writes WebP, AVIF or JPEG; SVG and GIF are passed through untouched so nothing ever breaks.

It runs the same engine as ImageResizer.cc, the free online tool by the same team. Need to handle a one-off file without opening WordPress? Use the web app at imageresizer.cc/app — same engine, any browser, nothing uploaded.

What makes it different

• Zero server load — all the work runs in the browser via WebAssembly, so nothing times out and your host isn’t taxed, even on cheap shared hosting.
• Nothing is uploaded — your originals never leave the site; the browser does all the work.
• No API key, no signup, no limits — no credits to buy, no monthly quota, no account. Free, unlimited image compression, always.
• Target file size — hit an exact size (100, 300, 500 KB…), not just a guessed quality value.
• Max width — scale huge photos down to a longest-edge cap before they are stored.
• HEIC to WebP or AVIF — turn iPhone photos and other heavy formats into modern, lighter ones on upload.
• Leaner thumbnails — the sub-sizes WordPress builds on the server use your chosen quality too.
• Works everywhere — Safari, iOS and every modern browser; fully translatable, with language packs delivered by WordPress.

How you use it

You don’t. Upload the way you already do — the plugin works on the upload itself, so there is no button to press, no queue to start and no bulk job to babysit.

Drop files into the Media Library as usual and each one is compressed in your browser before WordPress stores it. Writing a post is the same: add an Image block, upload, and the file that lands on your site is already the smaller one — the original never leaves your computer.

Set the target size and format once in the ImReso menu and you can forget about it. The screenshots below show both, alongside the dashboard that adds up what you saved.

Supported formats

• Read / resize / compress: JPEG, PNG, WebP, AVIF, BMP, TIFF.
• Read & convert to a web format: HEIC / HEIF (iPhone), plus TIFF and BMP.
• Output: WebP, AVIF or JPEG (chosen automatically or fixed in settings).
• Left untouched (uploaded as-is): GIF, whether animated or not (re-encoding would drop frames), SVG (vector), ICO and JPEG 2000. These are uploaded unchanged so nothing is ever broken.
• Already small: a JPEG, PNG, WebP or AVIF under 10 KB is left alone — re-encoding one rarely saves anything and can cost you quality. HEIC, TIFF and BMP are always converted, whatever their size, because the point there is a web-friendly format rather than a smaller file. So a tiny test image is expected to come through untouched.

What gets optimized

Uploads on the media and editor screens: the classic Media Library (upload.php), the Add New Media screen, the “Add Media” dialog and Media Library popup, and inline uploads in the block (post/page) editor — drag-and-drop, paste, and the block “Upload” button.

Everywhere the block editor runs is covered, so that also includes the Site Editor on a block theme and the block widgets screen on a classic one.

Programmatic / REST / WP-CLI / FTP uploads cannot be processed by any client-side tool, including this one.

About ImageResizer.cc

This plugin is made by the team behind ImageResizer.cc — a free, privacy-first online tool to resize, compress and convert images entirely in the browser. The plugin brings that same engine straight into your WordPress upload flow.

Working outside WordPress? The web app handles the same jobs with no install: compress an image to a target size, convert HEIC to JPG, or convert PNG to WebP — all client-side, nothing uploaded, no account.

Source code

Nothing in this plugin is obfuscated. The files under build/ are minified for delivery only. The complete, un-minified sources that produce them ship inside the plugin, and the same tree is public at

https://github.com/AlexStack/imreso-target-size-image-compressor

What ships:

• src-js/ — every TypeScript/JavaScript source file (worker engine, main-thread client, uploader interceptors, format sniffer). build/ir-worker.js, build/worker-client.js, build/classic-uploader.js and build/block-uploader.js are built from these.
• build.mjs — the esbuild configuration that bundles src-js/ into build/.

• package.json — declares the third-party packages listed below. The versions the shipped build/ was produced from are recorded in licenses/README.txt.

  build/chunks/ holds the lazily loaded pieces esbuild split out. They are minified derivatives, not verbatim copies, and they come from three places:

• Third-party — encode-*.js, avif_enc-*.js, webp_enc-*.js and webp_enc_simd-*.js are the @jsquash codecs; UTIF-*.js is utif2 (which bundles pako); heic-to-*.js is heic-to, and at ~3 MB it is the largest file in the plugin — it is libheif compiled to plain JavaScript, so HEIC decoding needs no extra binary. The readable originals are the npm packages listed under “Third-party libraries” below, reproduced verbatim by npm install; their full licence texts ship in licenses/.

• Ours — one chunk-*.js is built from src-js/wfd-shim.js.
• Generated by the build — another chunk-*.js carrying esbuild’s own CommonJS interop runtime, and avif_enc_mt-*.js, a one-line stub build.mjs substitutes for the multi-threaded AVIF codec so it is never bundled.

The eight-character hash in each chunk filename is content-derived, so these exact names change whenever a dependency does.

To regenerate everything in build/ from those sources, run this from the plugin folder:

The rebuilt build/ is functionally identical. The four .wasm codecs and the four top-level bundles come out byte-for-byte the same. The lazily loaded files under build/chunks/ carry an esbuild content hash in their filename (heic-to-<hash>.js); that hash is derived from the chunk’s contents, so it moves whenever a dependency version does, and the import statements in ir-worker.js move with it. The chunk contents are unchanged and each build/ is internally consistent. The hash is what stops browsers serving a stale chunk after a plugin update.

The .wasm files

They are the stock, unmodified binaries published by the @jsquash packages: npm install fetches byte-identical files and build.mjs copies them next to the bundle. Nothing is fetched at runtime — they are loaded from the plugin folder, which is what keeps every image on the user’s own device.

Each is compiled from a public, GPL-compatible upstream C/C++ project:

• webp_enc.wasm, webp_enc_simd.wasm — libwebp (BSD-3-Clause) — https://chromium.googlesource.com/webm/libwebp
• mozjpeg_enc.wasm — mozjpeg (BSD-3-Clause / IJG) — https://github.com/mozilla/mozjpeg
• avif_enc.wasm — libavif (BSD-2-Clause) — https://github.com/AOMediaCodec/libavif — with libaom — https://aomedia.googlesource.com/aom

The build scripts that produce these binaries from those sources are published by jSquash:

https://github.com/jamsinclair/jSquash

Third-party libraries

This plugin bundles the following GPL-compatible open-source libraries. The full text of each licence ships in the plugin’s licenses/ directory, with the exact bundled versions; upstream sources are linked below.

• @jsquash/avif, @jsquash/webp, @jsquash/jpeg — Apache-2.0 — WebAssembly image codecs — https://github.com/jamsinclair/jSquash
• heic-to — LGPL-3.0 — HEIC/HEIF decoding (wraps libheif) — https://github.com/hoppergee/heic-to
• utif2 — MIT — TIFF decoding — https://github.com/photopea/UTIF.js
• pako — MIT AND Zlib — zlib inflate, bundled inside utif2 — https://github.com/nodeca/pako

The codec binaries these packages ship are compiled from libwebp (BSD-3-Clause), mozjpeg (BSD-3-Clause / IJG), libavif + libaom (BSD-2-Clause with the Alliance for Open Media patent grant) and libheif (LGPL-3.0).

Because libheif and heic-to are LGPL-3.0, the combined work is distributed under GPLv3 as permitted by this plugin’s “GPLv2 or later” licence.