exifr vs exiftool-vendored Performance Analysis

[bpatrik]

I asked AI to plot up a quick perfomarnce benchmark. Here is the result:

NOTE: Report and test are fully AI generated, so take it with a hint of salt

Benchmark run on the demo folder of this project, so anyone can recreate it.

I. Report

exifr vs exiftool-vendored Performance Analysis

Executive Summary

The benchmark results clearly demonstrate that exifr significantly outperforms exiftool-vendored on Windows, with performance differences ranging from 6x to 66x faster depending on configuration.

Test Environment

• Platform: Windows 10/11 x64
• CPU: Intel Core i7-6700HQ @ 2.60GHz (8 cores)
• Node.js: v22.17.1
• Test Files: 20 JPEG images from demo/images directory (ranging from ~18KB to ~1.1MB)

Benchmark Results

Performance Summary

Library	Configuration	Total Time	Files/sec	Avg Time/File	Relative Speed
exifr	concurrent	34ms	588.24	18.89ms	Baseline (Fastest)
exifr	sequential	402ms	49.75	19.95ms	11.8x slower
exiftool-vendored	default sequential	2374ms	8.42	118.60ms	69.8x slower
exiftool-vendored	optimized concurrent	2244ms	8.91	1506.45ms*	66.0x slower

*Note: The optimized concurrent average time appears inflated due to measurement methodology - individual file times were higher due to process coordination overhead.

Key Findings

1. exifr concurrent processing is dramatically faster:

   • Processes 20 files in just 34ms vs 2244ms for best exiftool-vendored
   • Achieves 588 files/second vs ~9 files/second for exiftool-vendored

2. Windows process spawning penalty confirmed:

   • Even optimized exiftool-vendored with 8 concurrent processes couldn't overcome the Windows subprocess overhead
   • First file in exiftool-vendored took 533ms vs 5ms minimum for exifr

3. Memory efficiency:

   • exifr: ~5MB RSS overhead for concurrent processing
   • exiftool-vendored: ~1-4MB RSS overhead
   • Both libraries have reasonable memory footprints

4. Error handling:

   • exifr: 1 error on "broken image.JPG" (expected)
   • exiftool-vendored: 0 errors (handled broken image gracefully)

Analysis of exiftool-vendored Author's Suggestions

The exiftool-vendored author's suggestions were implemented in our optimized test:

• ✅ maxProcs set to CPU count: Used all 8 CPU cores
• ✅ Increased timeout: Set to 30 seconds for Windows
• ✅ Concurrent processing: Tested with Promise.all()
• ✅ Multiple files: Tested with 20 files

Despite these optimizations, exiftool-vendored still performed significantly slower due to:

1. Windows subprocess overhead: Each exiftool process spawn incurs significant latency
2. IPC overhead: Communication between Node.js and exiftool processes
3. Process coordination: Managing multiple exiftool processes adds overhead

Recommendations

For PiGallery2 (Performance-Critical Application)

Recommendation: Continue using exifr

Reasons:

1. Performance: 66x faster processing enables better user experience
2. Efficiency: Critical for Raspberry Pi deployment where CPU is limited
3. Scalability: Better concurrent processing for batch operations
4. Memory: Lower memory footprint important for embedded devices

When exiftool-vendored Might Still Be Considered

Consider exiftool-vendored only if:

• Metadata completeness is more important than performance
• Specific metadata fields are only available through exiftool
• Robustness for handling broken/unusual files is critical
• Application runs primarily on Linux/Unix (better subprocess performance)

Hybrid Approach (If Needed)

If specific exiftool features are required:

// Use exifr for primary metadata extraction (fast)
const primaryMetadata = await exifr.parse(file, options);

// Use exiftool only for specialized fields when needed
const specializedData = await exiftool.read(file, specificTags);

Performance Impact on PiGallery2

Based on these results, switching to exiftool-vendored would:

• Scanning: Make initial photo indexing 66x slower
• User Experience: Significantly delay thumbnail generation and gallery browsing
• Resource Usage: Increase CPU time per operation by ~6600%
• Scalability: Reduce concurrent processing capability dramatically

For a Raspberry Pi deployment processing hundreds or thousands of photos, this would translate to:

• Current (exifr): ~1000 photos in ~34 seconds
• With exiftool-vendored: ~1000 photos in ~37 minutes

Conclusion

The benchmark confirms your initial concern about exiftool-vendored performance on Windows. The dramatic performance difference (66x slower) makes exiftool-vendored unsuitable for PiGallery2's use case, especially given the application's focus on Raspberry Pi deployment where performance is critical.

Final Recommendation: Keep using exifr for PiGallery2's metadata extraction needs.

II. Benchmark code:

import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import * as exifr from 'exifr';
import { exiftool, ExifTool } from 'exiftool-vendored';

interface BenchmarkResult {
  library: string;
  configuration: string;
  totalFiles: number;
  totalTime: number;
  averageTime: number;
  minTime: number;
  maxTime: number;
  memoryUsage: NodeJS.MemoryUsage;
  errors: number;
}

async function getTestFiles(): Promise<string[]> {
  const demoDir = path.join(process.cwd(), 'demo', 'images');
  const files = fs.readdirSync(demoDir, { recursive: true, withFileTypes: true });

  return files
    .filter(file => file.isFile() && /\.(jpg|jpeg|tiff|tif|png)$/i.test(file.name))
    .map(file => path.join(file.path || demoDir, file.name))
    .slice(0, 20); // Limit to first 20 files for reasonable test time
}

async function benchmarkExifr(files: string[]): Promise<BenchmarkResult> {
  const exifrOptions = {
    tiff: true,
    xmp: true,
    icc: false,
    jfif: false,
    ihdr: true,
    iptc: true,
    exif: true,
    gps: true,
    reviveValues: false,
    translateValues: false,
    mergeOutput: false
  };

  const times: number[] = [];
  let errors = 0;
  const startMemory = process.memoryUsage();

  console.log('Testing exifr (sequential)...');
  const totalStart = Date.now();

  for (const file of files) {
    const start = Date.now();
    try {
      await exifr.parse(file, exifrOptions);
      const time = Date.now() - start;
      times.push(time);
      process.stdout.write('.');
    } catch (error) {
      errors++;
      process.stdout.write('E');
    }
  }

  const totalTime = Date.now() - totalStart;
  const endMemory = process.memoryUsage();
  console.log(`\nExifr sequential completed in ${totalTime}ms`);

  return {
    library: 'exifr',
    configuration: 'sequential',
    totalFiles: files.length,
    totalTime,
    averageTime: times.reduce((a, b) => a + b, 0) / times.length,
    minTime: Math.min(...times),
    maxTime: Math.max(...times),
    memoryUsage: {
      rss: endMemory.rss - startMemory.rss,
      heapTotal: endMemory.heapTotal - startMemory.heapTotal,
      heapUsed: endMemory.heapUsed - startMemory.heapUsed,
      external: endMemory.external - startMemory.external,
      arrayBuffers: endMemory.arrayBuffers - startMemory.arrayBuffers
    },
    errors
  };
}

async function benchmarkExifrConcurrent(files: string[]): Promise<BenchmarkResult> {
  const exifrOptions = {
    tiff: true,
    xmp: true,
    icc: false,
    jfif: false,
    ihdr: true,
    iptc: true,
    exif: true,
    gps: true,
    reviveValues: false,
    translateValues: false,
    mergeOutput: false
  };

  let errors = 0;
  const startMemory = process.memoryUsage();

  console.log('Testing exifr (concurrent)...');
  const totalStart = Date.now();

  const promises = files.map(async (file) => {
    const start = Date.now();
    try {
      await exifr.parse(file, exifrOptions);
      const time = Date.now() - start;
      process.stdout.write('.');
      return time;
    } catch (error) {
      errors++;
      process.stdout.write('E');
      return 0;
    }
  });

  const times = await Promise.all(promises);
  const validTimes = times.filter(t => t > 0);

  const totalTime = Date.now() - totalStart;
  const endMemory = process.memoryUsage();
  console.log(`\nExifr concurrent completed in ${totalTime}ms`);

  return {
    library: 'exifr',
    configuration: 'concurrent',
    totalFiles: files.length,
    totalTime,
    averageTime: validTimes.reduce((a, b) => a + b, 0) / validTimes.length,
    minTime: Math.min(...validTimes),
    maxTime: Math.max(...validTimes),
    memoryUsage: {
      rss: endMemory.rss - startMemory.rss,
      heapTotal: endMemory.heapTotal - startMemory.heapTotal,
      heapUsed: endMemory.heapUsed - startMemory.heapUsed,
      external: endMemory.external - startMemory.external,
      arrayBuffers: endMemory.arrayBuffers - startMemory.arrayBuffers
    },
    errors
  };
}

async function benchmarkExiftoolDefault(files: string[]): Promise<BenchmarkResult> {
  const times: number[] = [];
  let errors = 0;
  const startMemory = process.memoryUsage();

  console.log('Testing exiftool-vendored (default settings, sequential)...');
  const totalStart = Date.now();

  for (const file of files) {
    const start = Date.now();
    try {
      await exiftool.read(file);
      const time = Date.now() - start;
      times.push(time);
      process.stdout.write('.');
    } catch (error) {
      errors++;
      process.stdout.write('E');
    }
  }

  const totalTime = Date.now() - totalStart;
  const endMemory = process.memoryUsage();
  console.log(`\nExiftool default sequential completed in ${totalTime}ms`);

  return {
    library: 'exiftool-vendored',
    configuration: 'default-sequential',
    totalFiles: files.length,
    totalTime,
    averageTime: times.reduce((a, b) => a + b, 0) / times.length,
    minTime: Math.min(...times),
    maxTime: Math.max(...times),
    memoryUsage: {
      rss: endMemory.rss - startMemory.rss,
      heapTotal: endMemory.heapTotal - startMemory.heapTotal,
      heapUsed: endMemory.heapUsed - startMemory.heapUsed,
      external: endMemory.external - startMemory.external,
      arrayBuffers: endMemory.arrayBuffers - startMemory.arrayBuffers
    },
    errors
  };
}

async function benchmarkExiftoolOptimized(files: string[]): Promise<BenchmarkResult> {
  // Create optimized ExifTool instance
  const optimizedExiftool = new ExifTool({
    maxProcs: os.cpus().length, // Use all CPU cores as suggested
    taskTimeoutMillis: 30000,   // 30 second timeout as suggested for Windows
    maxTasksPerProcess: 500     // Allow more tasks per process
  });

  let errors = 0;
  const startMemory = process.memoryUsage();

  console.log(`Testing exiftool-vendored (optimized: ${os.cpus().length} procs, concurrent)...`);
  const totalStart = Date.now();

  const promises = files.map(async (file) => {
    const start = Date.now();
    try {
      await optimizedExiftool.read(file);
      const time = Date.now() - start;
      process.stdout.write('.');
      return time;
    } catch (error) {
      errors++;
      process.stdout.write('E');
      return 0;
    }
  });

  const times = await Promise.all(promises);
  const validTimes = times.filter(t => t > 0);

  const totalTime = Date.now() - totalStart;

  // Clean up the optimized instance
  await optimizedExiftool.end();

  const endMemory = process.memoryUsage();
  console.log(`\nExiftool optimized concurrent completed in ${totalTime}ms`);

  return {
    library: 'exiftool-vendored',
    configuration: `optimized-concurrent (${os.cpus().length} procs)`,
    totalFiles: files.length,
    totalTime,
    averageTime: validTimes.reduce((a, b) => a + b, 0) / validTimes.length,
    minTime: Math.min(...validTimes),
    maxTime: Math.max(...validTimes),
    memoryUsage: {
      rss: endMemory.rss - startMemory.rss,
      heapTotal: endMemory.heapTotal - startMemory.heapTotal,
      heapUsed: endMemory.heapUsed - startMemory.heapUsed,
      external: endMemory.external - startMemory.external,
      arrayBuffers: endMemory.arrayBuffers - startMemory.arrayBuffers
    },
    errors
  };
}

function printResults(results: BenchmarkResult[]) {
  console.log('\n' + '='.repeat(80));
  console.log('BENCHMARK RESULTS');
  console.log('='.repeat(80));
  console.log(`Platform: ${os.platform()} ${os.arch()}`);
  console.log(`CPUs: ${os.cpus().length} (${os.cpus()[0].model})`);
  console.log(`Node.js: ${process.version}`);
  console.log('='.repeat(80));

  results.forEach(result => {
    console.log(`\n${result.library} (${result.configuration}):`);
    console.log(`  Files processed: ${result.totalFiles}`);
    console.log(`  Total time: ${result.totalTime}ms`);
    console.log(`  Average time per file: ${result.averageTime.toFixed(2)}ms`);
    console.log(`  Min/Max time: ${result.minTime}ms / ${result.maxTime}ms`);
    console.log(`  Files per second: ${(result.totalFiles / result.totalTime * 1000).toFixed(2)}`);
    console.log(`  Errors: ${result.errors}`);
    console.log(`  Memory delta (RSS): ${(result.memoryUsage.rss / 1024 / 1024).toFixed(2)}MB`);
    console.log(`  Memory delta (Heap): ${(result.memoryUsage.heapUsed / 1024 / 1024).toFixed(2)}MB`);
  });

  console.log('\n' + '='.repeat(80));
  console.log('PERFORMANCE COMPARISON');
  console.log('='.repeat(80));

  const fastest = results.reduce((prev, current) =>
    current.totalTime < prev.totalTime ? current : prev
  );

  results.forEach(result => {
    const ratio = result.totalTime / fastest.totalTime;
    const percentage = ((ratio - 1) * 100).toFixed(1);
    const status = result === fastest ? ' (FASTEST)' : ` (+${percentage}% slower)`;
    console.log(`${result.library} (${result.configuration}): ${result.totalTime}ms${status}`);
  });
}

async function main() {
  try {
    console.log('Getting test files...');
    const files = await getTestFiles();
    console.log(`Found ${files.length} image files for testing`);
    console.log('Files:', files.map(f => path.basename(f)).join(', '));

    const results: BenchmarkResult[] = [];

    // Test exifr sequential
    results.push(await benchmarkExifr(files));

    // Wait a bit between tests to let memory settle
    console.log('Waiting 2 seconds...');
    await new Promise(resolve => setTimeout(resolve, 2000));

    // Test exifr concurrent
    results.push(await benchmarkExifrConcurrent(files));

    console.log('Waiting 2 seconds...');
    await new Promise(resolve => setTimeout(resolve, 2000));

    // Test exiftool-vendored default
    results.push(await benchmarkExiftoolDefault(files));

    console.log('Waiting 2 seconds...');
    await new Promise(resolve => setTimeout(resolve, 2000));

    // Test exiftool-vendored optimized
    results.push(await benchmarkExiftoolOptimized(files));

    // Print comprehensive results
    printResults(results);

  } catch (error) {
    console.error('Benchmark failed:', error);
    process.exit(1);
  } finally {
    // Clean up default exiftool instance
    await exiftool.end();
  }
}

main().catch(console.error);

[evrial]

exifr:
📑 Reads only first few bytes
🔬 Skips parsing tags you don't need

explains all this. I think we need a binary solution for large galleries to check if file has EXIF or not, as first filter. Maybe write in Zig or Rust lang

[rhatguy]

This is more just a high level thought than a suggestion, please take it as such as I respect @bpatrik's clearly in depth analysis and goals for the project.

It seems like with the last commit to exifr being over 4 years ago now, at some point a change in libraries will be necessitated whether to support new features or for maintainability. At what point would those (or other) reasons outweigh the clear performance advantage that exifr has? With hardware speeds increasing all the time, and I assume many PiGallery2 users running indexing in batch (at night), is indexing speed the trump card?

I can say for my use case (I'm running on a huge server) that the speed of the video transcoding will always dwarf the speed of indexing for me. Sure every so often I might add a picture and immediately view it before I run indexing, but then if it took an extra few seconds to index those pictures it wouldn't be the end of the world.

Just providing one users perspective. Feel free to disregard.

[evrial]

Pi in the name should explain all.
#1089
MikeKovarik/exifr#137

[bpatrik]

I generally agree with @rhatguy I also started using a stronger machine (i7, 32gb ram, ssd). For me indexing runs for 5mins for 80k images. But I know that some ppl still use it on low end devices and I would like to keep supporting them a bit longer. (I remember someone said their gallery takes O(days) to index).

The 66x slowdown is not really acceptable for me. Even if that would mean using the golden standard of exiftool . I could live with a 2x slowdown at max.

Metadaloader is a rather important and mediumly complex part of the app. Unfortunately when last year there was the change to exifr, it was already deprecated and I did not have the time to do again a proper market research. Metadaloader was migrated from one deprecated lib to an other, but also we did not win much with it as it still uses 3-4 different ways to load metadata and now it seems that exifr also has a memory leak. see #1080 #1070

I would love to see a solution that 1) keeps the speed (or at least does not significantly degrade) 2) reduces the number of dependencies 3) no deprecated. I was thinking looking into sharp as the app already uses it for thumbnail generation and it can also read metadata. (not sure about sidecars tho)