Skip to Content
New: ssim-native brings SSIM, MS-SSIM and Hitchhiker's to Node, and interpret-native ships diff interpretation on its own. Read more β†’
APIs@blazediff/core-native

@blazediff/core-native

The fastest single-threaded image diff in the world. Native Rust implementation with SIMD optimization, 4.4-4.9x faster and 3x smaller than odiffΒ .

View Detailed BenchmarksΒ 

This package was previously published as @blazediff/bin, which is now deprecated. Please use @blazediff/core-native instead.

Installation

npm install @blazediff/core-native

Also available as a Rust crate: cargo install blazediff

Pre-built binaries are included for all major platforms - no compilation required:

  • macOS ARM64 (Apple Silicon) & x64 (Intel)
  • Linux ARM64 & x64
  • Windows ARM64 & x64

Features

  • PNG, JPEG & QOI support - auto-detected by file extension or encoded bytes
  • 4.4-4.9x faster than odiff, 3x smaller binaries (~700KB-900KB vs ~2-3MB)
  • SIMD-accelerated - NEON on ARM, SSE4.1 on x86
  • Block-based optimization - skips unchanged regions
  • Interpret mode - region detection, classification, severity scoring, human-readable summaries

Vendored Libraries

  • libspngΒ  - Fast PNG decoding/encoding with SIMD
  • libjpeg-turboΒ  - High-performance JPEG codec with SIMD
  • qoiΒ  - QOI (Quite OK Image) format for fast lossless compression

API Reference

compare(base, comparison, diffOutput, options?)

Compares two images from file paths or encoded Buffer/Uint8Array inputs and optionally generates a diff image. Both inputs must use the same input type. Format is auto-detected from the file extension or encoded bytes.

Parameters

ParameterTypeDescription
basestring | Uint8ArrayBase/expected image path or encoded bytes
comparisonstring | Uint8ArrayComparison/actual image path or encoded bytes
diffOutputstringPath where the diff image will be saved
optionsBlazeDiffOptionsComparison options (optional)
Options
OptionTypeDefaultDescription
thresholdnumber0.1Color difference threshold (0.0-1.0). Lower = more strict
antialiasingbooleanfalseEnable anti-aliasing detection
diffMaskbooleanfalseOutput only differences with transparent background
diffColorAlt[number, number, number]diff colorAlternative RGB color for darkening differences

Return Types

type BlazeDiffResult = | { match: true } | { match: false; reason: "layout-diff" } | { match: false; reason: "pixel-diff"; diffCount: number; diffPercentage: number } | { match: false; reason: "file-not-exists"; file: string };

Encoded inputs are passed by reference across the N-API boundary. Rust borrows the existing JavaScript backing memory for the synchronous call. Image decoding still allocates native RGBA pixel buffers.

Threshold Guidelines:

  • 0.0 - Exact match only
  • 0.05 - Strict comparison
  • 0.1 - Default balanced comparison
  • 0.2 - Lenient comparison

Usage

Programmatic API

import { compare } from '@blazediff/core-native'; const result = await compare('expected.png', 'actual.png', 'diff.png', { threshold: 0.1, antialiasing: true, }); if (result.match) { console.log('Images are identical!'); } else if (result.reason === 'pixel-diff') { console.log(`${result.diffCount} pixels differ (${result.diffPercentage.toFixed(2)}%)`); } else if (result.reason === 'layout-diff') { console.log('Images have different dimensions'); }

Encoded Buffer Input

import { readFile } from "node:fs/promises"; import { compare } from "@blazediff/core-native"; const [expected, actual] = await Promise.all([ readFile("expected.png"), readFile("actual.png"), ]); // Reuse these same Buffer objects across comparisons without a JS-to-Rust copy. const result = await compare(expected, actual, "diff.png");

CLI Usage

# Compare two PNG images npx blazediff expected.png actual.png diff.png # Compare two JPEG images npx blazediff expected.jpg actual.jpg diff.jpg # Compare two QOI images npx blazediff expected.qoi actual.qoi diff.qoi # Mixed formats (PNG input, QOI output - recommended for smallest diff files) npx blazediff expected.png actual.png diff.qoi # With options npx blazediff expected.png actual.png diff.png --threshold 0.05 --antialiasing # With higher PNG compression (smaller output file, slower) npx blazediff expected.png actual.png diff.png -c 6 # With JPEG quality setting npx blazediff expected.jpg actual.jpg diff.jpg -q 85 # Output as text format npx blazediff expected.png actual.png diff.png --output-format text

CLI Options

blazediff [OPTIONS] <IMAGE1> <IMAGE2> [OUTPUT] Arguments: <IMAGE1> First image path (PNG, JPEG, or QOI) <IMAGE2> Second image path (PNG, JPEG, or QOI) [OUTPUT] Output diff image path (optional, format detected from extension) Options: -t, --threshold <THRESHOLD> Color difference threshold (0.0-1.0) [default: 0.1] -a, --antialiasing Enable anti-aliasing detection --diff-mask Output only differences (transparent background) --diff-color-alt <R,G,B> Alternative RGB color for darkening differences -c, --compression <LEVEL> PNG compression level (0-9, 0=fastest, 9=smallest) [default: 0] -q, --quality <QUALITY> JPEG quality (1-100) [default: 90] --output-format <FORMAT> Output format (json or text) [default: json] -h, --help Print help -V, --version Print version

Supported Formats

FormatExtensionsNotes
PNG.pngLossless, supports transparency
JPEG.jpg, .jpegLossy, smaller file sizes
QOI.qoiFast lossless, ideal for diff outputs (12x smaller than uncompressed PNG)

Input images can be mixed formats (e.g., compare PNG to JPEG). Output format is determined by the output file extension.

Use QOI for diff outputs: QOI excels at encoding diff images with large uniform areas, producing files 12x smaller than PNG (level 0) while being faster to encode.

Exit Codes

  • 0 - Images are identical
  • 1 - Images differ (includes layout/size mismatch)
  • 2 - Error (file not found, invalid format, etc.)

Interpret

Structured region analysis is a separate package. This one answers where pixels differ; @blazediff/interpret-native takes the same pair and describes what changed β€” labelled regions, severity and a human-readable summary β€” and can locate those regions with a pixel diff, an SSIM map, or boxes you already have.

import { interpret } from '@blazediff/interpret-native'; const result = await interpret('expected.png', 'actual.png'); console.log(result.summary); // "Moderate visual change detected (1.87% of image, 4 regions). // Content changed: 1 region (bottom). // Content added: 2 regions (right, bottom-left)."

See Interpret example β†’ for the interactive demo.

Performance

Benchmarked on Apple M1 Max with 5600Γ—3200 4K images (25 runs, 5 warmup, image IO included):

ToolTimeComparison
blazediff (encoded buffer input)~203ms-
blazediff (file paths)~275ms-
odiff~1266ms4.6x slower

These are end-to-end times, so PNG decode and encode dominate them. The diff kernel itself is 27–37% faster than the previous release on 4K buffers; that gain is diluted here because IO is the larger share of the total.

Binary sizes (stripped, LTO optimized):

Platformblazediffodiff
macOS ARM64702 KB2.2 MB
Linux x64869 KB2.9 MB
Windows x64915 KB3.0 MB

Why so fast? BlazeDiff uses a two-pass block-based algorithm with SIMD acceleration. The cold pass quickly identifies unchanged blocks using 32-bit integer comparison, then the hot pass only processes changed regions with YIQ perceptual color difference. Three refinements keep the common paths cheap: the cold pass folds four SIMD chunks into one wide test, so 16 unchanged pixels cost a single branch; an integer bound derived from the YIQ metric’s largest eigenvalue rejects sub-threshold pixels before any floating-point work; and chunks where nothing crosses the threshold take a vectorized background write instead of falling back to per-pixel handling.