DEV Community: aissam

How I Made Sharp 950x Faster (And Why It Matters After Bun Joined Anthropic)

aissam — Sun, 14 Dec 2025 10:27:23 +0000

Bun just joined Anthropic.

Claude Code now ships as a Bun executable to millions of users. This isn't just news — it's a signal. The JavaScript ecosystem is shifting.

But here's what nobody's talking about:

Sharp wasn't built for this future.

The Problem With Sharp

Don't get me wrong — Sharp is excellent. It's battle-tested. It powers thousands of production apps.

But it has limitations:

No native HEIC support out-of-the-box
- Requires building libvips from source
- Custom Docker layers for Lambda
- Complex CI/CD pipelines
Metadata extraction is slow
- Decodes the entire image just to read dimensions
- For a 10MB image, that's reading 10MB instead of ~100 bytes
Heavy under concurrent load
- Not optimized for modern serverless architectures

I hit all these walls while building an image-heavy application. Processing thousands of images was slow. Servers were expensive. Users were waiting.

So I did something about it.

Introducing bun-image-turbo

A Rust-powered image processing library designed for Bun and Node.js from day one.

100% open source. MIT licensed. Free forever.

npm install bun-image-turbo

That's it. No custom builds. No compilation. Native HEIC support included.

The Benchmarks

Tested on Apple M1 Pro with Bun 1.3.3:

Operation	Sharp	bun-image-turbo	Improvement
WebP Metadata	3.4ms	0.004ms	950x faster
JPEG Metadata	0.1ms	0.003ms	38x faster
PNG Metadata	0.08ms	0.002ms	40x faster
50 Concurrent Ops	160ms	62ms	2.6x faster
Transform Pipeline	19.1ms	12.2ms	1.6x faster
HEIC Support	❌ (needs custom build)	✅ Native	∞

Why 950x Faster Metadata?

Most libraries decode the entire image to extract metadata.

Sharp approach:
10MB image → Decode all 10MB → Extract width/height → Done
Time: 3.4ms

bun-image-turbo reads only the header bytes:

bun-image-turbo approach:
10MB image → Read ~100 bytes header → Extract width/height → Done
Time: 0.004ms

Same result. 950x less work.

The Full Optimization Stack

1. Header-Only Metadata

Only read what you need. Don't decode pixels for metadata.

2. Shrink-on-Decode

For JPEG and HEIC, decode directly at reduced resolution:

4000px original → Need 200px thumbnail
Sharp: Decode 4000px → Resize to 200px
bun-image-turbo: Decode at 500px (1/8 scale) → Resize to 200px

Fewer pixels = faster processing.

3. Multi-Step Resize

For large downscales, progressive halving is faster:

4000px → 2000px → 1000px → 500px → 200px

Each step uses Box filter (optimal for downscaling).

4. Adaptive Algorithm Selection

Automatically selects the best filter:

Scale Factor	Algorithm	Why
>4x downscale	Box	Fastest, good averaging
2-4x downscale	Bilinear	Fast, acceptable quality
<2x downscale	Lanczos3	Best quality

5. TurboJPEG with SIMD

Uses libjpeg-turbo with hardware acceleration:

SSE2/AVX2 on x86
NEON on ARM

2-6x faster than standard libjpeg.

Real-World Impact

Before (Sharp):

📊 Processing 1000 user uploads...
⏱️  Metadata: 10.4s
⏱️  Thumbnails: 45.2s
⏱️  WebP conversion: 38.1s
💀 Server CPU: 98%

After (bun-image-turbo):

📊 Processing 1000 user uploads...
⏱️  Metadata: 0.28s (37x faster)
⏱️  Thumbnails: 23.5s (1.9x faster)
⏱️  WebP conversion: 19.8s (1.9x faster)
😎 Server CPU: 45%

Translation: Fewer servers. Lower costs. Happier users.

Quick Start

import { 
  metadata, 
  resize, 
  transform, 
  toWebp, 
  blurhash 
} from 'bun-image-turbo';

// Read image
const buffer = Buffer.from(await Bun.file('photo.jpg').arrayBuffer());

// Get metadata (950x faster than Sharp!)
const info = await metadata(buffer);
console.log(`${info.width}x${info.height} ${info.format}`);

// Resize with shrink-on-decode
const thumbnail = await resize(buffer, { width: 200 });

// Full transform pipeline
const result = await transform(buffer, {
  resize: { width: 800, height: 600, fit: 'cover' },
  rotate: 90,
  grayscale: true,
  sharpen: 10,
  output: { format: 'webp', webp: { quality: 85 } }
});

// Built-in Blurhash (Sharp doesn't have this!)
const { hash } = await blurhash(buffer, 4, 3);

// Save
await Bun.write('output.webp', result);

Works with Node.js too:

import { readFileSync, writeFileSync } from 'fs';
import { transform } from 'bun-image-turbo';

const buffer = readFileSync('photo.jpg');
const result = await transform(buffer, {
  resize: { width: 800 },
  output: { format: 'webp' }
});
writeFileSync('output.webp', result);

Platform Support

7 prebuilt binaries. No compilation needed.

Platform	Architecture	Supported	HEIC
macOS	ARM64 (M1/M2/M3/M4)	✅	✅
macOS	x64 (Intel)	✅	❌
Linux	x64 (glibc)	✅	❌
Linux	x64 (musl/Alpine)	✅	❌
Linux	ARM64	✅	❌
Windows	x64	✅	❌
Windows	ARM64	✅	❌

What's Coming Next

This is just v1.2.0. Here's the roadmap:

🔜 AVIF write support
🔜 Streaming API for large files
🔜 More filters & effects
🔜 WebAssembly build for edge runtimes
🔜 Even more performance optimizations

Why Open Source?

I could have kept this proprietary. Built a SaaS around it.

But the JavaScript ecosystem gave me everything. Node.js. Bun. npm. Thousands of open source packages.

This is my contribution back.

100% open source. MIT licensed. Free forever.

Use it. Fork it. Contribute. Make it better.

Links

📖 Documentation: nexus-aissam.github.io/bun-image-turbo

⭐ GitHub: github.com/nexus-aissam/bun-image-turbo

📦 npm: npm install bun-image-turbo

The Bottom Line

What You Get	Value
Metadata extraction	950x faster
Concurrent operations	2.6x faster
Transform pipelines	1.6x faster
HEIC support	Native (no custom builds)
Blurhash	Built-in
Price	Free forever

Bun joined Anthropic. The ecosystem is evolving.

Build for the future.

npm install bun-image-turbo

Got questions? Drop them in the comments.

Found this useful? Star the repo ⭐

Built a Sharp Alternative That’s 36x Faster - And It Works with Both Bun AND Node.js

aissam — Sun, 07 Dec 2025 18:00:17 +0000

TL;DR: I built bun-image-turbo, a Rust-powered image processing library that outperforms Sharp in most benchmarks. It's 36x faster at metadata extraction, 4.5x faster under concurrent load, and has built-in Blurhash support. Works seamlessly with Bun and Node.js.

Stop Waiting for Your Images to Process

Every millisecond counts. Your users are waiting. Your server is sweating.

You're processing 1,000 product images for your e-commerce site. With Sharp, that's 10 seconds of metadata extraction. With bun-image-turbo? Under 300ms.

That's not a typo. 36x faster.

The Problem with Image Processing in Node.js

We've all been there. You're building an image-heavy application - maybe an e-commerce platform, a CMS, or a social media app. You reach for Sharp because it's the go-to solution.

But then you hit these walls:

Metadata extraction feels slow when processing thousands of images
Your server struggles under concurrent image operations
You need Blurhash placeholders but have to add another dependency
Complex transform pipelines eat up precious milliseconds
You want to try Bun but your image library doesn't fully support it

I decided to solve this. From scratch. In Rust.

Introducing bun-image-turbo

Works with Bun 1.0+ AND Node.js 18+ - Use the same code everywhere

# Bun
bun add bun-image-turbo

# Node.js / npm
npm install bun-image-turbo

# yarn
yarn add bun-image-turbo

# pnpm
pnpm add bun-image-turbo

A high-performance image processing library built with:

Rust for blazing fast performance
TurboJPEG (libjpeg-turbo) with SIMD acceleration
napi-rs for seamless Node.js/Bun integration
Zero-copy buffers for minimal memory overhead
100% TypeScript with full type definitions

The Benchmarks Don't Lie

"Show me the numbers" - Every developer ever

Tested on Apple M1 Pro with Bun 1.3.3 vs Sharp v0.34.5:

┌─────────────────────────────────────────────────────────────────────────────┐
│                    bun-image-turbo vs sharp Performance                     │
├─────────────────────────────────────────────────────────────────────────────┤
│ Metadata Extraction     █████████████████████████████████████  36x faster   │
│ Transform Pipeline      ████████████████████                   3.4x faster  │
│ Concurrent (50 ops)     ██████████████████████████             4.5x faster  │
│ JPEG Encode             ██████████████                         1.9x faster  │
│ Thumbnail Resize        ████████████                           1.9x faster  │
│ Blurhash Generation     ████████████████████ (4,283 ops/sec)   N/A in sharp │
└─────────────────────────────────────────────────────────────────────────────┘

The Numbers (ops/sec - higher is better)

Operation	bun-image-turbo	sharp	Winner
Metadata Extraction	350,000 ops/sec	9,600 ops/sec	36x faster
Transform Pipeline	454 ops/sec	134 ops/sec	3.4x faster
Concurrent (50 ops)	1,653 ops/sec	364 ops/sec	4.5x faster
JPEG Encode	553 ops/sec	287 ops/sec	1.9x faster

Why 36x Faster Metadata?

Sharp decodes the entire image to extract metadata. bun-image-turbo only reads the header bytes. For a 10MB image, that's the difference between reading 10MB vs ~100 bytes.

Your Server Will Thank You

Before (Sharp):

📊 Processing 1000 user uploads...
⏱️  Metadata: 10.4s
⏱️  Thumbnails: 45.2s
⏱️  WebP conversion: 38.1s
💀 Server CPU: 98%

After (bun-image-turbo):

📊 Processing 1000 user uploads...
⏱️  Metadata: 0.28s (36x faster)
⏱️  Thumbnails: 23.5s (1.9x faster)
⏱️  WebP conversion: 19.8s (1.9x faster)
😎 Server CPU: 45%

Dead Simple API

The API is designed to be intuitive and familiar:

import { resize, toWebp, metadata, transform, blurhash } from 'bun-image-turbo';

// Get metadata (350,000 ops/sec!)
const info = await metadata(buffer);
console.log(`${info.width}x${info.height} ${info.format}`);

// Resize with high-quality Lanczos3
const thumb = await resize(buffer, { width: 200 });

// Convert to modern formats
const webp = await toWebp(buffer, { quality: 85 });

// Complex pipeline in ONE call (3.4x faster than Sharp)
const result = await transform(buffer, {
  resize: { width: 400, height: 300, fit: 'cover' },
  rotate: 90,
  grayscale: true,
  sharpen: 10,
  output: { format: 'webp', webp: { quality: 80 } }
});

// Built-in Blurhash (4,283 ops/sec) - No extra dependency!
const { hash } = await blurhash(buffer, 4, 3);
// "LEHV6nWB2yk8pyo0adR*.7kCMdnj"

Sync APIs for When You Need Them

import { resizeSync, metadataSync, transformSync } from 'bun-image-turbo';

// Blocking operations when async isn't needed
const info = metadataSync(buffer);
const thumb = resizeSync(buffer, { width: 200 });

Server Workloads? We Got You

The 4.5x improvement under concurrent load is where bun-image-turbo really shines for production servers:

// Process 50 images concurrently
const results = await Promise.all(
  images.map(img => resize(img, { width: 800 }))
);
// bun-image-turbo: 30ms total (1,653 ops/sec)
// sharp: 137ms total (364 ops/sec)

This means your API can handle 4.5x more image requests before you need to scale.

Real-World Impact

Scenario	Sharp	bun-image-turbo	Savings
10K daily uploads	2 servers	1 server	$50/month
100K daily uploads	8 servers	2 servers	$300/month
1M daily uploads	40 servers	10 servers	$1,500/month

Estimated based on 4.5x throughput improvement

Works Everywhere

Runtime Support:

✅ Bun 1.0+ - First-class support, optimized for Bun
✅ Node.js 18+ - Full compatibility, same API

Platform Support:

Platform	Architecture	Status
macOS	ARM64 (M1/M2/M3)	✅
macOS	x64 (Intel)	✅
Linux	x64 (glibc)	✅
Linux	x64 (musl/Alpine)	✅
Linux	ARM64	✅
Windows	x64	✅
Windows	ARM64	✅

7 prebuilt binaries - No compilation needed. Just npm install and go.

Migration from Sharp is Easy

// Before (Sharp)
import sharp from 'sharp';
const result = await sharp(buffer)
  .resize(400, 300)
  .rotate(90)
  .grayscale()
  .webp({ quality: 80 })
  .toBuffer();

// After (bun-image-turbo)
import { transform } from 'bun-image-turbo';
const result = await transform(buffer, {
  resize: { width: 400, height: 300 },
  rotate: 90,
  grayscale: true,
  output: { format: 'webp', webp: { quality: 80 } }
});

Same result. 3.4x faster.

When to Use bun-image-turbo

Use it when you need:

Fast metadata extraction (image galleries, validation)
High-concurrency image processing (APIs, workers)
Transform pipelines (thumbnail generation)
Blurhash placeholders (lazy loading)
Bun OR Node.js compatibility
Production performance at scale

Stick with Sharp when you need:

Animated GIF processing
Advanced color space manipulation
SVG rendering

Get Started in 30 Seconds

With Bun:

import { transform } from 'bun-image-turbo';

const input = await Bun.file('photo.jpg').arrayBuffer();

const optimized = await transform(Buffer.from(input), {
  resize: { width: 1200 },
  output: { format: 'webp', webp: { quality: 85 } }
});

await Bun.write('photo.webp', optimized);

With Node.js:

import { transform } from 'bun-image-turbo';
import { readFile, writeFile } from 'fs/promises';

const input = await readFile('photo.jpg');

const optimized = await transform(input, {
  resize: { width: 1200 },
  output: { format: 'webp', webp: { quality: 85 } }
});

await writeFile('photo.webp', optimized);

Why I Built This

I was building an image-heavy SaaS and hit performance walls with existing solutions. The metadata extraction was killing my upload pipeline. Concurrent processing was melting my servers.

So I did what any reasonable developer would do: rewrote it in Rust.

6 months, 10,000 lines of Rust, and countless benchmarks later - here we are.

What's Next?

AVIF support (coming soon)
Streaming API for large files
More filter options
WebAssembly build for edge runtimes

Star the repo if this helps you! ⭐

The Bottom Line

Metric	Improvement
Metadata extraction	36x faster
Concurrent operations	4.5x faster
Transform pipelines	3.4x faster
JPEG encoding	1.9x faster
Server costs	Up to 75% less

Stop leaving performance on the table. Your images deserve better.

npm install bun-image-turbo

Built with Rust, powered by libjpeg-turbo, made for the modern JavaScript ecosystem.

Works with Bun. Works with Node.js. Just works.

Tags: #javascript #rust #nodejs #bun #webdev #performance #opensource #imageprocessing #webp #optimization

Meet Mongoose Test Factory!

aissam — Tue, 23 Sep 2025 21:31:01 +0000

Stop Writing Mock Data by Hand - Meet Mongoose Test Factory!

Are you tired of writing endless lines of mock data for your MongoDB tests? What if I told you there's a way to generate realistic test data with literally ZERO configuration?

The Problem We All Face

// We've ALL written this boring code...
const mockUser = {
  name: "John Doe",
  email: "john@example.com",
  age: 25,
  isActive: true,
  // ... 50 more fields
};

const anotherMockUser = {
  name: "Jane Smith",
  email: "jane@example.com",
  age: 30,
  // Copy-paste-modify hell continues...
};

Sound familiar? Writing test data is:

Time-consuming
Error-prone
Mind-numbingly boring
Repetitive across projects

The Game Changer

What if you could do this instead:

// 1. Apply one plugin
userSchema.plugin(mongooseTestFactory);

// 2. Generate infinite realistic data
const user = User.factory().build();
// Output: { name: "Emma Rodriguez", email: "emma.rodriguez@gmail.com", age: 28, isActive: true }

const users = await User.factory(100).create(); // 100 users in the DB!

That's it. No configuration. No setup. Just intelligent, realistic data.

Meet Mongoose Test Factory

I built this plugin because I was frustrated with existing solutions that required complex configuration or generated unrealistic data. Here's what makes it special:

It's Actually Intelligent

Recognizes field names: firstName generates names, userEmail generates emails
Respects ALL your Mongoose validators automatically
Understands relationships and generates proper ObjectIds

Three Power Modes

// Lightning-fast objects for unit tests
const user = User.factory().build();

// Full Mongoose instances with methods/virtuals
const user = User.factory().make();

// Persisted to database for integration tests
const user = await User.factory().create();

TypeScript Lovers Rejoice

interface IUserModel extends mongoose.Model<IUser> {
  findByEmail(email: string): Promise<IUser | null>;
}

// Preserves ALL your custom methods + adds factory
const User = withFactory<IUser, IUserModel>(UserModel);

User.findByEmail('test@example.com');  // Your method
User.factory().build();               // Factory magic

Real-World Example

Here's an e-commerce schema that would take forever to mock manually:

const productSchema = new Schema({
  name: { type: String, required: true },
  price: { type: Number, min: 0.01, max: 9999.99 },
  category: { type: String, enum: ['electronics', 'clothing', 'books'] },
  description: String,
  inStock: { type: Boolean, default: true },
  tags: [String],
  ratings: [{
    user: { type: ObjectId, ref: 'User' },
    score: { type: Number, min: 1, max: 5 }
  }]
});

productSchema.plugin(mongooseTestFactory);
const Product = withFactory(mongoose.model('Product', productSchema));

// Generate 50 products with realistic data, proper prices,
// valid categories, and even nested ratings!
const products = await Product.factory(50).create();

The plugin automatically:

Generates product names that make sense
Creates prices within your min/max range
Picks valid categories from your enum
Builds nested rating objects with proper ObjectIds
Ensures all validation rules are met

Performance That Scales

// Need 10,000 test records? No problem!
await User.factory(10000).create(); // Optimized batch processing

// Reproducible tests across your team
FactoryPlugin.initialize({ seed: 12345 });

The Developer Experience

What developers are saying:

"Went from 30 minutes of setup to 30 seconds. This is magic!"
"Finally, a factory that understands my schema without me explaining it."
"The TypeScript support is chef's kiss"

Try It Right Now!

npm install --save-dev mongoose-test-factory

Literally 3 lines to get started:

import mongooseTestFactory, { withFactory } from 'mongoose-test-factory';

userSchema.plugin(mongooseTestFactory);
const User = withFactory(UserModel);
const user = User.factory().build(); // Done!

Why I Built This

As a full-stack developer, I was spending more time writing test data than actual tests. Every project needed the same boring setup:

Write mock data by hand
Copy-paste across files
Debug when schema changes
Repeat for every model

There had to be a better way.

After trying every existing solution and finding them lacking, I built Mongoose Test Factory with one goal: Make test data generation invisible.

What's Next?

I'm constantly improving based on community feedback:

More locale support for international data
Advanced relationship handling
Custom data generators
Performance monitoring

Want to contribute? The project is open source and I'd love your input!

Links:

NPM Package: https://www.npmjs.com/package/mongoose-test-factory
GitHub Repository: https://github.com/nexus-aissam/mongoose-test-factory
Full Documentation: https://github.com/nexus-aissam/mongoose-test-factory#readme

What do you think? Have you struggled with test data generation? What's your current approach? Let me know in the comments!

If this saves you time, drop a star on GitHub - it means the world to indie developers like me!

Happy coding!