QuickShrink: Browser Image Compressor, No Uploads

I got tired of uploading personal photos to random websites just to shrink them. So I built QuickShrink — an image compressor that runs entirely in your browser. Your images never touch a server.

The Dirty Secret of “Free” Image Compressors

Go ahead and Google “compress image online.” You’ll find dozens of tools, all with the same pitch: drop your image, we’ll compress it, download the result.

Here’s what they don’t tell you: your photo gets uploaded to their server. A server in a data center you’ve never seen, governed by a privacy policy you’ve never read, in a jurisdiction you might not even recognize. That family photo (which might be broadcasting your GPS location), that screenshot of your bank statement, that product image for your client — it’s now sitting on someone else’s disk.

Some of these services explicitly state they delete uploads after an hour. Others are silent on the matter. A few have been caught in breaches. The point isn’t that they’re malicious — it’s that there’s no reason for the upload to happen in the first place.

The Canvas API Makes Servers Unnecessary

Modern browsers ship with the Canvas API — a powerful image processing engine built into Chrome, Firefox, Safari, and Edge. It can decode an image, manipulate its pixels, and re-encode it at any quality level. All of this happens in memory, on your device, using your CPU.

QuickShrink leverages this. When you drop an image:

1. The browser reads the file into memory (no network request)
2. A Canvas element renders the image at its native resolution
3. canvas.toBlob() re-encodes it as JPEG at your chosen quality (10%–100%)
4. You download the result directly from browser memory

Total data transmitted over the network: zero bytes.

Under the Hood: How Canvas API Compression Actually Works

To understand why browser-based compression works so well, it helps to know what JPEG compression actually does under the surface. It’s not just “make the file smaller” — it’s a multi-stage pipeline that exploits how human vision works.

JPEG compression works in five distinct stages:

1. Color space conversion (RGB → YCbCr). Your image starts as red, green, and blue channels. The encoder converts it into luminance (brightness) and two chrominance (color) channels. This separation is key — human eyes are far more sensitive to brightness than to color.
2. Chroma subsampling. Since our eyes barely notice color detail, the encoder reduces the resolution of the two color channels. A common scheme is 4:2:0, which halves the color resolution in both dimensions — cutting color data to 25% of its original size with almost no perceptible difference.
3. Discrete Cosine Transform (DCT) on 8×8 pixel blocks. The image is divided into 8×8 pixel blocks, and each block is transformed from spatial data (pixel values) into frequency data (patterns of light and dark). Low-frequency components represent smooth gradients; high-frequency components represent sharp edges and fine detail.
4. Quantization — this is where quality loss happens. The frequency data from each block is divided by a quantization matrix and rounded. High-frequency components (fine detail) get divided by larger numbers, effectively zeroing them out. This is the lossy step — and it’s where the quality parameter has its effect.
5. Huffman encoding. Finally, the quantized data is compressed using lossless Huffman coding, which replaces common patterns with shorter bit sequences. This is the same principle behind ZIP compression — no data is lost in this step.

When you call canvas.toBlob() with a quality parameter, the browser’s built-in JPEG encoder runs all of these steps. The quality parameter (0.0 to 1.0) controls step 4 — quantization. Lower quality means more aggressive quantization, which produces a smaller file but introduces more artifacts. Higher quality preserves more detail but results in a larger file.

Here’s how the browser’s compression maps to these steps in practice:

// The browser handles all the complexity behind this one call
canvas.toBlob(
  (blob) => {
    // blob is your compressed image
    console.log(`Compressed: ${blob.size} bytes`);
  },
  'image/jpeg',
  0.8  // quality: 0.0 (max compression) to 1.0 (no compression)
);

That single method call triggers the entire five-stage pipeline. The browser’s native JPEG encoder — written in optimized C++ and compiled to machine code — handles color conversion, DCT transforms, quantization, and Huffman coding. You get the output of a sophisticated compression algorithm through one line of JavaScript.

The Complete Compression Pipeline: File → Canvas → Blob → Download

Understanding the theory is useful, but let’s look at how the full pipeline works in practice. Here’s the complete compression function that QuickShrink uses at its core:

async function compressImage(file, quality = 0.8) {
  // Step 1: Read file into an Image object
  const img = await createImageBitmap(file);
  
  // Step 2: Create canvas at original dimensions
  const canvas = document.createElement('canvas');
  canvas.width = img.width;
  canvas.height = img.height;
  
  // Step 3: Draw image onto canvas
  const ctx = canvas.getContext('2d');
  ctx.drawImage(img, 0, 0);
  
  // Step 4: Re-encode as JPEG at target quality
  const blob = await new Promise(resolve => {
    canvas.toBlob(resolve, 'image/jpeg', quality);
  });
  
  // Step 5: Calculate savings
  const savings = ((file.size - blob.size) / file.size * 100).toFixed(1);
  console.log(`${file.name}: ${formatBytes(file.size)} → ${formatBytes(blob.size)} (${savings}% saved)`);
  
  return blob;
}

function formatBytes(bytes) {
  if (bytes === 0) return '0 B';
  const k = 1024;
  const sizes = ['B', 'KB', 'MB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
}

The download trigger is equally straightforward — we create a temporary object URL, simulate a click on an anchor element, and immediately clean up:

function downloadBlob(blob, filename) {
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = filename.replace(/\.[^.]+$/, '_compressed.jpg');
  document.body.appendChild(a);
  a.click();
  document.body.removeChild(a);
  URL.revokeObjectURL(url); // free memory
}

The entire pipeline — from file selection to download — happens in under 500ms for a typical 3MB photo. No network round-trips, no upload progress bars, no waiting for a server to process your image. The bottleneck is your CPU’s JPEG encoder, which on any modern device is blazingly fast.

EXIF Data: The Privacy Metadata You Forgot About

Every photo your phone takes is embedded with invisible metadata called EXIF data. This includes GPS coordinates (often accurate to within a few meters), your camera model and serial number, the exact timestamp the photo was taken, and even the software used to edit it. If you’ve ever wondered how someone could figure out where a photo was taken — EXIF is the answer.

The amount of data stored in EXIF is staggering. A typical iPhone photo contains over 40 metadata fields: latitude and longitude, altitude, lens aperture, shutter speed, ISO, focal length, white balance, flash status, orientation, color space, and device-specific identifiers. Some Android phones even include the device’s unique hardware ID. When you share that photo — compressed or not — all of that metadata travels with it unless explicitly removed.

Here’s the problem: most “compress” tools keep EXIF data intact. Your compressed image still broadcasts your location, your device information, and your editing history. You think you’re just making a file smaller, but you’re passing along a dossier of metadata to whoever receives the image.

QuickShrink can show you what EXIF data exists in your image before stripping it. Here’s the code that reads EXIF markers from a JPEG file:

// Read EXIF data from JPEG to show user what's being removed
function readExifData(file) {
  return new Promise((resolve) => {
    const reader = new FileReader();
    reader.onload = function(e) {
      const view = new DataView(e.target.result);
      
      // JPEG starts with 0xFFD8
      if (view.getUint16(0) !== 0xFFD8) {
        resolve({ hasExif: false });
        return;
      }
      
      // Find EXIF marker (0xFFE1)
      let offset = 2;
      while (offset < view.byteLength) {
        const marker = view.getUint16(offset);
        if (marker === 0xFFE1) {
          resolve({
            hasExif: true,
            exifSize: view.getUint16(offset + 2),
            message: 'EXIF data found — GPS, camera info, timestamps will be stripped'
          });
          return;
        }
        offset += 2 + view.getUint16(offset + 2);
      }
      resolve({ hasExif: false });
    };
    reader.readAsArrayBuffer(file.slice(0, 128 * 1024)); // only read first 128KB
  });
}

When QuickShrink draws your image onto a Canvas and re-exports it, the Canvas API creates a brand new JPEG file. EXIF data from the original doesn’t carry over. This means compression through QuickShrink doubles as a privacy tool — your compressed photos won’t contain GPS coordinates, camera serial numbers, or editing software metadata. If you want a dedicated tool for this, check out PixelStrip, which I built specifically for EXIF removal.

Benchmarks: Real Numbers From Real Photos

Theory is nice, but numbers are better. I ran a set of real-world photos through QuickShrink at three different quality levels to see how the compression performs across different image types:

A few patterns emerge from these numbers. Screenshots compress the most aggressively because they contain large areas of flat color and sharp text — patterns that JPEG’s DCT transform handles efficiently. The 8×8 pixel blocks in a screenshot often contain identical or near-identical values, which quantize down to almost nothing. Photos with complex textures (landscapes, aerials) still see significant savings, but the encoder has to work harder to preserve fine detail like grass, foliage, and water ripples.

Notice that even at 40% quality, the drone aerial drops from 12.3 MB to 1.6 MB — an 87% reduction. For web use, email, or social media, this is more than adequate. Most social platforms recompress your uploads anyway, so starting with a leaner file means faster uploads and less double-compression artifacting.

Want to run your own benchmarks? Here’s a function that tests multiple quality levels and prints a comparison table:

// Run your own benchmarks
async function benchmarkCompression(file) {
  const qualities = [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3];
  const results = [];
  
  const img = await createImageBitmap(file);
  const canvas = document.createElement('canvas');
  canvas.width = img.width;
  canvas.height = img.height;
  const ctx = canvas.getContext('2d');
  ctx.drawImage(img, 0, 0);
  
  for (const q of qualities) {
    const start = performance.now();
    const blob = await new Promise(r => canvas.toBlob(r, 'image/jpeg', q));
    const time = (performance.now() - start).toFixed(1);
    
    results.push({
      quality: `${q * 100}%`,
      size: formatBytes(blob.size),
      saved: `${((file.size - blob.size) / file.size * 100).toFixed(1)}%`,
      time: `${time}ms`
    });
  }
  
  console.table(results);
  return results;
}

The sweet spot for most use cases is 70–80% quality. Below 60%, text in screenshots becomes noticeably fuzzy. Above 90%, you’re barely saving any space. I personally use 75% as the default in QuickShrink because it balances file size and visual quality for the widest range of image types.

The Results Are Surprisingly Good

At 80% quality (the default), most photos shrink by 40–60% with no visible degradation. At 60%, you’re looking at 70–80% reduction — still good enough for web use, email attachments, and social media. Only below 30% do you start seeing compression artifacts.

The interface shows you exact numbers: original size, compressed size, and percentage saved. No guessing.

It’s Also a PWA

QuickShrink is a Progressive Web App — one of several free browser tools that can replace desktop apps. On mobile, your browser will offer to “Add to Home Screen.” On desktop Chrome, you’ll see an install icon in the address bar. Once installed, it launches in its own window, works offline, and feels like a native app — because functionally, it is one.

The entire application is a single HTML file with inline CSS and JavaScript. No build tools, no framework, no dependencies. It loads in under 200ms on any connection.

Try It

👉 quickshrink.orthogonal.info

Open source, zero tracking, free forever. If you find it useful, share it with someone who’s still uploading their photos to compress them.

Frequently Asked Questions