jimp

An image processing library written entirely in JavaScript.

weekly downloads1.9M

versionv1.6.0

licenseMIT

categoryutility

imageimage processingimage manipulationpngjpgjpegbmpresizescalecrop

Overview

Jimp (JavaScript Image Manipulation Program) is a comprehensive image processing library built entirely in JavaScript for Node.js environments. Unlike alternatives that rely on native bindings to C/C++ libraries like libvips or ImageMagick, Jimp operates purely in JavaScript, making it highly portable across platforms without compilation requirements or system dependencies.

The library provides a Promise-based API for common image operations including resizing, cropping, color manipulation, filters, and format conversion. It supports PNG, JPEG, BMP, GIF, and TIFF formats out of the box, with extensibility through a plugin architecture. With nearly 2 million weekly downloads, Jimp has become a go-to solution for developers who need image processing capabilities without the complexity of native dependencies.

Jimp excels in scenarios where deployment simplicity and cross-platform compatibility matter more than raw performance. It's particularly useful in serverless environments, Docker containers, or CI/CD pipelines where installing native dependencies can be problematic. The trade-off is slower processing compared to native solutions, making it less suitable for high-throughput production workloads that process thousands of images per second.

The library's chainable API and straightforward syntax make it accessible to developers of all skill levels. Operations can be composed fluently, and the async/await support integrates cleanly with modern JavaScript codebases. While performance limitations exist, Jimp's reliability and ease of use have established it as a stable choice for moderate-scale image processing tasks.

Quick Start

typescript

const Jimp = require('jimp');
const path = require('path');

async function processUserAvatar(inputPath, outputDir) {
  try {
    const image = await Jimp.read(inputPath);
    
    const thumbnail = image
      .clone()
      .cover(200, 200, Jimp.HORIZONTAL_ALIGN_CENTER | Jimp.VERTICAL_ALIGN_MIDDLE)
      .quality(80)
      .greyscale()
      .contrast(0.2);
    
    await thumbnail.writeAsync(path.join(outputDir, 'avatar-thumb.jpg'));
    
    const banner = image
      .clone()
      .resize(800, Jimp.AUTO)
      .blur(2)
      .brightness(0.1);
    
    const logo = await Jimp.read('logo.png');
    logo.resize(100, Jimp.AUTO);
    
    banner.composite(logo, 10, 10, {
      mode: Jimp.BLEND_SOURCE_OVER,
      opacitySource: 0.7
    });
    
    await banner.writeAsync(path.join(outputDir, 'banner.png'));
    
    const metadata = {
      width: image.bitmap.width,
      height: image.bitmap.height,
      mime: image.getMIME()
    };
    
    return metadata;
  } catch (error) {
    throw new Error(`Image processing failed: ${error.message}`);
  }
}

processUserAvatar('./uploads/profile.jpg', './processed')
  .then(meta => console.log('Processed:', meta))
  .catch(err => console.error(err));

Use Cases

Automated thumbnail generation: Create multiple thumbnail sizes from uploaded user images in web applications, particularly useful in headless CMS systems or blogging platforms where you need to generate responsive image variants without complex infrastructure.

Watermarking and branding: Programmatically add logos, text overlays, or watermarks to images in batch processing scripts, such as protecting copyrighted content or adding branding to dynamically generated social media graphics.

Image optimization pipelines: Build pre-deployment scripts that compress, resize, and optimize images for web delivery in static site generators or build tools, reducing page load times without manual intervention.

Serverless image processing: Deploy image manipulation functions in AWS Lambda, Vercel, or Netlify Functions where native dependencies are difficult to manage, such as generating open graph images or processing user uploads on the fly.

Data visualization preprocessing: Prepare images for machine learning workflows or computer vision tasks by normalizing dimensions, applying filters, or converting formats in Node.js-based data pipelines without Python dependencies.

Pros & Cons

Pros

+Zero native dependencies means no compilation steps, making deployment across platforms trivial and eliminating common installation failures
+Comprehensive API covering most common image operations with a consistent, chainable interface that's easy to learn and use
+Plugin architecture allows extending functionality with custom operations or additional format support
+Works reliably in restricted environments like serverless functions, Docker containers, and CI/CD runners without system library requirements
+Pure JavaScript implementation makes debugging easier since you're not crossing native boundaries

Cons

−Significantly slower than native alternatives like Sharp (5-10x performance difference for common operations like resize)
−Larger bundle size due to pure JavaScript implementation of image codecs, increasing memory footprint
−Not suitable for high-throughput production environments processing hundreds or thousands of images concurrently
−Limited advanced features compared to ImageMagick or GraphicsMagick (no PSD support, limited color space operations)
−Synchronous operations can block the event loop for large images despite Promise-based API, affecting application responsiveness

Alternatives

sharpv0.34.5

High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images

utilityjpegpng

31.9M / week

Comparisons

sharp vs jimp

utility

Install

bash

npm install jimp

bash

pnpm add jimp

bash

bun add jimp

Overview

Quick Start

typescript

const Jimp = require('jimp');
const path = require('path');

async function processUserAvatar(inputPath, outputDir) {
  try {
    const image = await Jimp.read(inputPath);
    
    const thumbnail = image
      .clone()
      .cover(200, 200, Jimp.HORIZONTAL_ALIGN_CENTER | Jimp.VERTICAL_ALIGN_MIDDLE)
      .quality(80)
      .greyscale()
      .contrast(0.2);
    
    await thumbnail.writeAsync(path.join(outputDir, 'avatar-thumb.jpg'));
    
    const banner = image
      .clone()
      .resize(800, Jimp.AUTO)
      .blur(2)
      .brightness(0.1);
    
    const logo = await Jimp.read('logo.png');
    logo.resize(100, Jimp.AUTO);
    
    banner.composite(logo, 10, 10, {
      mode: Jimp.BLEND_SOURCE_OVER,
      opacitySource: 0.7
    });
    
    await banner.writeAsync(path.join(outputDir, 'banner.png'));
    
    const metadata = {
      width: image.bitmap.width,
      height: image.bitmap.height,
      mime: image.getMIME()
    };
    
    return metadata;
  } catch (error) {
    throw new Error(`Image processing failed: ${error.message}`);
  }
}

processUserAvatar('./uploads/profile.jpg', './processed')
  .then(meta => console.log('Processed:', meta))
  .catch(err => console.error(err));

Use Cases

Pros & Cons

Pros

+Zero native dependencies means no compilation steps, making deployment across platforms trivial and eliminating common installation failures
+Comprehensive API covering most common image operations with a consistent, chainable interface that's easy to learn and use
+Plugin architecture allows extending functionality with custom operations or additional format support
+Works reliably in restricted environments like serverless functions, Docker containers, and CI/CD runners without system library requirements
+Pure JavaScript implementation makes debugging easier since you're not crossing native boundaries

Cons

−Significantly slower than native alternatives like Sharp (5-10x performance difference for common operations like resize)
−Larger bundle size due to pure JavaScript implementation of image codecs, increasing memory footprint
−Not suitable for high-throughput production environments processing hundreds or thousands of images concurrently
−Limited advanced features compared to ImageMagick or GraphicsMagick (no PSD support, limited color space operations)
−Synchronous operations can block the event loop for large images despite Promise-based API, affecting application responsiveness