What happened

The piece opens on a plain annoyance. Confidential family photos, passport scans, and client assets travel “across oceans” so someone can delete white pixels.

“Across oceans” is the author’s name for the upload itself. The file leaves for someone else’s server even though the edit could have stayed on the machine where the picture is already open.

Then comes the converter storefront. The pitch says to upload the image to an “AI engine.” A loading bar runs for about 30 seconds. The next screen says the one free credit for the month is gone, and high resolution costs $19.99/mo.

HelpMyIMG is the author’s counter-offer. Canvas cropping, compression, WebP encoding, and segmentation — the step people use when they cut a background — run in sandboxed browser memory. The operation itself does not need a round trip.

The main thread is not the one chewing pixels. The bitmap goes to a Web Worker, and drawing happens on an OffscreenCanvas, so the page stays responsive while the file is built.

The snippet in the post defaults quality to 0.82. A comment on that code claims a 70–85% size reduction in about 40 ms with no network I/O. That figure belongs to the encode step, not to the comparison table further down.

export async function compressImageWorker(imageBitmap, quality = 0.82) {
  const canvas = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
  const ctx = canvas.getContext('2d', { willReadFrequently: true });
  ctx.drawImage(imageBitmap, 0, 0);
  const blob = await canvas.convertToBlob({ type: 'image/webp', quality });
  return blob;
}

The step is readable without memorizing the API. The function takes an ImageBitmap that already exists, builds an OffscreenCanvas of the same size, draws the bitmap, and asks the canvas for a WebP file at the given quality. What comes back is a file, not a URL on a server.

willReadFrequently appears in the context call exactly as the author wrote it. The note does not say why the flag is on, and it does not show a separate timing with and without it.

The prose also says basic manipulation — segmentation, canvas cropping, compression, and WebP encoding — can run in browser memory at 60 frames per second on modern WebAssembly and Canvas APIs. The note does not attach a device log to that sentence.

The table he publishes in full:

The same note names the other service’s price twice, and the free cap twice. The storefront copy says one free credit a month and $19.99. The table says 50 credits on the free tier and $19.90 a month. Those are not two speed tests. They are two places where he prices the cloud product. His own row is marked $0.

The live demo he points to is the service page.

Why it matters

A passport scan and a client photo are not stock wallpaper. Once the bytes sit on someone else’s API, that infrastructure has seen them, even when the task was “trim the margin.”

For a family it is an album. For someone filling in a form it is a document. For a studio it is a client folder. The note argues with the same move in all three cases: shipping the original for an edit the tab can already do.

The table states the payload as 12 MB versus 0 KB. Zero kilobytes means the picture stays on the machine. It does not add a security claim the post never makes.

120 ms versus 4.2 s is local work versus a full HTTP round trip. The cloud number also sits next to a credit cap and a subscription. The storefront line says $19.99 a month; the table says $19.90. Both are the author’s prices for the other service. He prices his own at $0.

The worker is there so the tab does not freeze. Pixel work on OffscreenCanvas inside a Web Worker leaves the main thread free to scroll, instead of performing a 30-second loading bar.

The same table states the limit without softening it: “unlimited” means the user’s hardware. Skipping the upload does not turn a laptop into a render farm.

In practice

Split the decision in two. Do not upload a confidential or client file merely to crop or compress it. Do not run heavy pixel work on the main thread if the page still has to respond.

The snippet is a shape for one step, not a finished product. Check it against the page you actually ship.

1. For cropping, compression, WebP, and background cuts via segmentation, see whether the tab’s memory is enough before you add an upload.
2. Hand the ImageBitmap to a Web Worker and draw on OffscreenCanvas, not on the page canvas.
3. Encode with convertToBlob and type image/webp. The sample defaults quality to 0.82; the comment claims about 70–85% off the file size in ~40 ms with no network.
4. Read expectations from the published table: about 120 ms locally versus 4.2 s for the HTTP round trip, 0 KB versus 12 MB, $0 versus roughly $19.90–$19.99 a month.
5. Treat the hardware ceiling as real: the table does not promise a boundless cloud, only the computer in front of the user.
6. Do not copy the “60 frames per second” line into your own docs as a measurement. In the note it is a capability claim, without a separate method.

Takeaway

A white margin on a scan is not worth an overseas shipment. In this note, cropping, compression, WebP, and segmentation stay in the tab: OffscreenCanvas in a Web Worker, about 120 ms versus 4.2 s, a 70–85% smaller file, and $0 instead of a paid cloud API.

If the picture never leaves, the other server never sees it. After that, the cap is the machine with the tab open, not a monthly credit.