Sharp: High-Performance Image Processing for Node.js

What is Sharp?

Sharp is a Node.js module for high-speed image processing, built on the libvips C library rather than pure JavaScript. It converts and resizes JPEG, PNG, WebP, GIF, AVIF, and TIFF images, and it runs on any JavaScript runtime with Node-API v9 support, including Node.js 20.9.0 or later, Deno, and Bun. Most modern macOS, Windows, and Linux systems can run it without installing extra native dependencies.

Supported Formats and Core Operations

• ✓Reads and converts JPEG, PNG, WebP, GIF, AVIF, and TIFF, per the README's supported format list
• ✓Resize operations built on Lanczos resampling, so image quality holds up at smaller dimensions
• ✓Handles colour spaces, embedded ICC profiles, and alpha transparency channels correctly during conversion
• ✓Rotation, cropping/extraction, compositing, and gamma correction on top of plain resizing
• ✓Accepts SVG as input, useful for masks and overlays in composite operations
• ✓Works as a stream, so a readable image source can pipe through a transform into a writable output

Common Use Cases for Sharp

• •Generating multiple thumbnail sizes for a web upload pipeline
• •Converting user-uploaded photos to WebP or AVIF before storage to cut file size
• •Resizing product images on the fly behind an API route
• •Compositing overlays, like rounded-corner masks or watermarks, onto images server-side

Installing Sharp

Run `npm install sharp`. That's the entire install path the README shows — no build step or config file needed for typical usage. For anything beyond that single command, the project links out to a separate installation guide on its docs site rather than covering platform-specific detail in the README itself.

Resizing and Converting Images with Code Examples

Import Sharp and start chaining operations; both ESM and CommonJS work. ```javascript // ESM import sharp from 'sharp'; // CJS const sharp = require('sharp'); ``` Resize and convert in one pass: ```javascript const output = await sharp('input.jpg') .autoOrient() .resize({ width: 200 }) .jpeg({ mozjpeg: true }) .toBuffer(); ``` Or resize straight to a file in a different format: ```javascript await sharp(inputBuffer) .resize({ width: 320, height: 240 }) .toFile('output.webp', (err, info) => { ... }); ``` Sharp also works as a stream. The README's rounded-corner example pipes a readable source through a `.composite()` call using an SVG mask and into a writable destination, without buffering the whole image in memory: ```javascript const roundedCorners = Buffer.from( '<svg><rect x="0" y="0" width="200" height="200" rx="50" ry="50"/></svg>' ); const roundedCornerResizer = sharp() .resize(200, 200) .composite([{ input: roundedCorners, blend: 'dest-in' }]) .png(); readableStream .pipe(roundedCornerResizer) .pipe(writableStream); ```

Alternatives to Sharp

When to Choose Sharp

Sharp fits teams already on Node.js, Deno, or Bun who need to resize, convert, or compress images inside their own request path — an upload handler, a thumbnail job, an on-the-fly image API — and want that work done in-process instead of shelling out to ImageMagick binaries. It's a poor fit if you need a dependency-free, pure-JavaScript image library, say for a constrained deploy target where compiling or shipping native binaries isn't an option.

Frequently Asked Questions

The problem it solves

Resizing or converting images inside a Node.js process usually means shelling out to an ImageMagick binary and eating its startup cost, or reaching for a pure-JS decoder that bogs down on anything past thumbnail size. That gets expensive fast under real request load. Sharp wraps libvips directly in a native Node-API module, so resize, format conversion, and compositing happen in-process at libvips' speed instead of through a child process or a slow JS-only codec.

Related repositories