Node.js 22 vs. Bun 1.1: npm Package Install Speed Benchmarks

const { spawn } = require('child_process');
const fs = require('fs/promises');
const path = require('path');
const { promisify } = require('util');

// Configuration: projects to benchmark (real-world production examples)
const BENCHMARK_PROJECTS = [
  { name: 'Express 4.18', repo: 'https://github.com/expressjs/express', deps: 112 },
  { name: 'NestJS 10', repo: 'https://github.com/nestjs/nest', deps: 1247 },
  { name: 'Next.js 14', repo: 'https://github.com/vercel/next.js', deps: 3421 },
  { name: 'Fastify 4', repo: 'https://github.com/fastify/fastify', deps: 89 },
  { name: 'Prisma 5', repo: 'https://github.com/prisma/prisma', deps: 2103 },
];

const CLONE_DIR = path.join(__dirname, 'benchmark-repos');
const ITERATIONS = 3; // Run each install 3 times to get average

/**
 * Spawns a child process and measures execution time
 * @param {string} command - Command to run
 * @param {string[]} args - Command arguments
 * @param {string} cwd - Working directory
 * @returns {Promise<{timeMs: number, success: boolean, error: string | null}>}
 */
async function measureCommand(command, args, cwd) {
  const start = Date.now();
  return new Promise((resolve) => {
    const proc = spawn(command, args, { cwd, stdio: 'pipe' });
    let error = null;
    proc.stderr.on('data', (data) => { error += data.toString(); });
    proc.on('close', (code) => {
      const timeMs = Date.now() - start;
      resolve({ timeMs, success: code === 0, error: error || null });
    });
    proc.on('error', (err) => {
      resolve({ timeMs: Date.now() - start, success: false, error: err.message });
    });
  });
}

/**
 * Clones a repo if not already present
 * @param {string} repoUrl - Git repo URL
 * @param {string} dirName - Directory name to clone to
 */
async function ensureRepo(repoUrl, dirName) {
  const repoDir = path.join(CLONE_DIR, dirName);
  try {
    await fs.access(repoDir);
    console.log(`Repo ${dirName} already cloned, skipping.`);
  } catch {
    console.log(`Cloning ${dirName}...`);
    const result = await measureCommand('git', ['clone', repoUrl, repoDir], __dirname);
    if (!result.success) {
      throw new Error(`Failed to clone ${repoUrl}: ${result.error}`);
    }
  }
  return repoDir;
}

async function runBenchmark() {
  // Create clone directory if not exists
  await fs.mkdir(CLONE_DIR, { recursive: true });
  console.log('Starting benchmark: Node.js 22 npm vs Bun 1.1');
  console.log('Hardware: AMD Ryzen 9 7900X, 32GB DDR5, 1Gbps Ethernet, Ubuntu 24.04');
  console.log('Versions: Node.js 22.0.0, npm 10.8.2, Bun 1.1.0');
  console.log('---');

  const results = [];

  for (const project of BENCHMARK_PROJECTS) {
    const repoDir = await ensureRepo(project.repo, project.name.replace(/\s/g, '-'));
    // Clean node_modules and lockfiles to simulate cold install
    await fs.rm(path.join(repoDir, 'node_modules'), { recursive: true, force: true });
    await fs.rm(path.join(repoDir, 'package-lock.json'), { force: true });
    await fs.rm(path.join(repoDir, 'bun.lockb'), { force: true });

    // Benchmark npm install
    const npmTimes = [];
    for (let i = 0; i < ITERATIONS; i++) {
      const result = await measureCommand('npm', ['install', '--no-audit', '--no-fund'], repoDir);
      if (result.success) npmTimes.push(result.timeMs);
      else console.error(`npm install failed for ${project.name}: ${result.error}`);
    }
    const avgNpmTime = npmTimes.length > 0 ? npmTimes.reduce((a, b) => a + b, 0) / npmTimes.length : null;

    // Benchmark bun install
    const bunTimes = [];
    for (let i = 0; i < ITERATIONS; i++) {
      const result = await measureCommand('bun', ['install'], repoDir);
      if (result.success) bunTimes.push(result.timeMs);
      else console.error(`bun install failed for ${project.name}: ${result.error}`);
    }
    const avgBunTime = bunTimes.length > 0 ? bunTimes.reduce((a, b) => a + b, 0) / bunTimes.length : null;

    results.push({
      project: project.name,
      deps: project.deps,
      avgNpmTime,
      avgBunTime,
      diffPercent: avgNpmTime && avgBunTime ? ((avgNpmTime - avgBunTime) / avgNpmTime * 100).toFixed(1) : null,
    });
  }

  // Output results as table
  console.log('\nBenchmark Results:');
  console.log('Project'.padEnd(20), 'Deps'.padEnd(8), 'npm Avg (ms)'.padEnd(15), 'Bun Avg (ms)'.padEnd(15), '% Faster (Bun)'.padEnd(15));
  for (const res of results) {
    console.log(
      res.project.padEnd(20),
      res.deps.toString().padEnd(8),
      (res.avgNpmTime?.toFixed(0) || 'FAIL').padEnd(15),
      (res.avgBunTime?.toFixed(0) || 'FAIL').padEnd(15),
      (res.diffPercent || 'N/A').padEnd(15)
    );
  }
}

runBenchmark().catch(console.error);

const { spawn } = require('child_process');
const fs = require('fs/promises');
const path = require('path');

// Configuration
const TEST_PROJECT = path.join(__dirname, 'test-project');
const NPM_CACHE_DIR = path.join(__dirname, '.npm-cache');
const BUN_CACHE_DIR = path.join(__dirname, '.bun-cache');
const ITERATIONS = 5;

/**
 * Measures install time with cache enabled/disabled
 * @param {'npm' | 'bun'} pm - Package manager
 * @param {boolean} cold - Whether to clear cache before install
 * @returns {Promise} Average install time in ms
 */
async function measureInstall(pm, cold) {
  // Clear cache if cold run
  if (cold) {
    if (pm === 'npm') {
      await fs.rm(NPM_CACHE_DIR, { recursive: true, force: true });
      await spawn('npm', ['config', 'set', 'cache', NPM_CACHE_DIR]).on('close', () => {});
    } else {
      await fs.rm(BUN_CACHE_DIR, { recursive: true, force: true });
    }
  }

  const times = [];
  for (let i = 0; i < ITERATIONS; i++) {
    // Clean node_modules and lockfiles
    await fs.rm(path.join(TEST_PROJECT, 'node_modules'), { recursive: true, force: true });
    await fs.rm(path.join(TEST_PROJECT, 'package-lock.json'), { force: true });
    await fs.rm(path.join(TEST_PROJECT, 'bun.lockb'), { force: true });

    const start = Date.now();
    const proc = spawn(pm === 'npm' ? 'npm' : 'bun', ['install'], { cwd: TEST_PROJECT });
    await new Promise((resolve) => {
      proc.on('close', (code) => {
        if (code === 0) times.push(Date.now() - start);
        resolve();
      });
      proc.on('error', resolve);
    });
  }

  return times.length > 0 ? times.reduce((a, b) => a + b, 0) / times.length : null;
}

async function setupTestProject() {
  // Create test project with 100 dependencies
  await fs.mkdir(TEST_PROJECT, { recursive: true });
  const packageJson = {
    name: 'cache-test-project',
    version: '1.0.0',
    dependencies: {},
  };
  // Add 100 random popular dependencies
  const deps = ['express', 'lodash', 'axios', 'react', 'vue', 'fastify', 'prisma', 'jest', 'typescript', 'eslint'];
  for (let i = 0; i < 10; i++) {
    for (const dep of deps) {
      packageJson.dependencies[`${dep}-${i}`] = `^${i + 1}`;
    }
  }
  await fs.writeFile(path.join(TEST_PROJECT, 'package.json'), JSON.stringify(packageJson, null, 2));
}

async function runCacheBenchmark() {
  await setupTestProject();
  console.log('Running Cache Benchmark: Node.js 22 npm vs Bun 1.1');
  console.log('Test Project: 100 dependencies');
  console.log('---');

  const results = {};

  // Benchmark npm
  console.log('Benchmarking npm...');
  results.npmCold = await measureInstall('npm', true);
  results.npmWarm = await measureInstall('npm', false); // Reuse cache
  console.log(`npm Cold: ${results.npmCold?.toFixed(0)}ms, Warm: ${results.npmWarm?.toFixed(0)}ms`);

  // Benchmark bun
  console.log('Benchmarking Bun...');
  results.bunCold = await measureInstall('bun', true);
  results.bunWarm = await measureInstall('bun', false); // Reuse global cache
  console.log(`Bun Cold: ${results.bunCold?.toFixed(0)}ms, Warm: ${results.bunWarm?.toFixed(0)}ms`);

  // Calculate cache efficiency
  const npmCacheGain = results.npmCold && results.npmWarm ? ((results.npmCold - results.npmWarm) / results.npmCold * 100).toFixed(1) : null;
  const bunCacheGain = results.bunCold && results.bunWarm ? ((results.bunCold - results.bunWarm) / results.bunCold * 100).toFixed(1) : null;

  console.log('\nCache Efficiency:');
  console.log(`npm: ${npmCacheGain}% faster warm vs cold`);
  console.log(`Bun: ${bunCacheGain}% faster warm vs cold`);
}

runCacheBenchmark().catch(console.error);

const fs = require('fs');
const path = require('path');
const { createObjectCsvWriter } = require('csv-writer').createObjectCsvWriter;

// Configuration
const BENCHMARK_RESULTS_DIR = path.join(__dirname, 'benchmark-results');
const REPORT_PATH = path.join(__dirname, 'benchmark-report.html');

/**
 * Parses raw benchmark log files into structured data
 * @param {string} logPath - Path to log file
 * @returns {Array<{project: string, npmTime: number, bunTime: number}>}
 */
function parseLogs(logPath) {
  const logs = fs.readFileSync(logPath, 'utf8').split('\n');
  const results = [];
  let currentProject = null;

  for (const line of logs) {
    if (line.startsWith('Project:')) {
      currentProject = line.split(':')[1].trim();
    } else if (line.startsWith('npm Avg:') && currentProject) {
      const npmTime = parseFloat(line.split(':')[1].trim());
      const existing = results.find(r => r.project === currentProject);
      if (existing) existing.npmTime = npmTime;
      else results.push({ project: currentProject, npmTime, bunTime: null });
    } else if (line.startsWith('Bun Avg:') && currentProject) {
      const bunTime = parseFloat(line.split(':')[1].trim());
      const existing = results.find(r => r.project === currentProject);
      if (existing) existing.bunTime = bunTime;
      else results.push({ project: currentProject, npmTime: null, bunTime });
    }
  }

  // Validate results
  const validResults = results.filter(r => r.npmTime && r.bunTime);
  if (validResults.length < results.length) {
    console.warn(`Warning: ${results.length - validResults.length} projects had missing data`);
  }
  return validResults;
}

/**
 * Generates an HTML report with charts
 * @param {Array} results - Structured benchmark results
 */
async function generateHtmlReport(results) {
  const html = `




  Node.js 22 vs Bun 1.1 Install Speed Benchmark Report
  Date: ${new Date().toISOString().split('T')[0]}
  Hardware: AMD Ryzen 9 7900X, 32GB DDR5, 1Gbps Ethernet, Ubuntu 24.04
  Versions: Node.js 22.0.0, npm 10.8.2, Bun 1.1.0

  Results Table

    ${results.map(r => `

    `).join('')}


      Project
      Dependencies
      Node.js 22 npm (ms)
      Bun 1.1 (ms)
      % Faster (Bun)

      ${r.project}
      ${r.deps}
      ${r.npmTime.toFixed(0)}
      ${r.bunTime.toFixed(0)}
      ${((r.npmTime - r.bunTime) / r.npmTime * 100).toFixed(1)}%


  Install Time Comparison Chart





    const ctx = document.getElementById('timeChart').getContext('2d');
    const chart = new Chart(ctx, {
      type: 'bar',
      data: {
        labels: ${JSON.stringify(results.map(r => r.project))},
        datasets: [
          {
            label: 'Node.js 22 npm',
            data: ${JSON.stringify(results.map(r => r.npmTime))},
            backgroundColor: 'rgba(54, 162, 235, 0.2)',
            borderColor: 'rgba(54, 162, 235, 1)',
            borderWidth: 1
          },
          {
            label: 'Bun 1.1',
            data: ${JSON.stringify(results.map(r => r.bunTime))},
            backgroundColor: 'rgba(255, 99, 132, 0.2)',
            borderColor: 'rgba(255, 99, 132, 1)',
            borderWidth: 1
          }
        ]
      },
      options: {
        scales: {
          y: { beginAtZero: true, title: { display: true, text: 'Install Time (ms)' } }
        }
      }
    });



  `;

  await fs.promises.writeFile(REPORT_PATH, html);
  console.log(`Report generated at ${REPORT_PATH}`);
}

async function runReportGenerator() {
  // Create results directory if not exists
  await fs.promises.mkdir(BENCHMARK_RESULTS_DIR, { recursive: true });

  // Parse all log files in results directory
  const logFiles = (await fs.promises.readdir(BENCHMARK_RESULTS_DIR)).filter(f => f.endsWith('.log'));
  if (logFiles.length === 0) {
    throw new Error('No log files found in benchmark-results directory');
  }

  const allResults = [];
  for (const logFile of logFiles) {
    const logPath = path.join(BENCHMARK_RESULTS_DIR, logFile);
    const results = parseLogs(logPath);
    allResults.push(...results);
  }

  // Deduplicate results by project, keep latest
  const uniqueResults = Array.from(new Map(allResults.map(r => [r.project, r])).values());

  // Generate CSV
  const csvWriter = createObjectCsvWriter({
    path: path.join(__dirname, 'benchmark-results.csv'),
    header: [
      { id: 'project', title: 'Project' },
      { id: 'deps', title: 'Dependencies' },
      { id: 'npmTime', title: 'Node.js 22 npm (ms)' },
      { id: 'bunTime', title: 'Bun 1.1 (ms)' },
      { id: 'diffPercent', title: '% Faster (Bun)' },
    ],
  });

  const csvData = uniqueResults.map(r => ({
    project: r.project,
    deps: r.deps,
    npmTime: r.npmTime.toFixed(0),
    bunTime: r.bunTime.toFixed(0),
    diffPercent: ((r.npmTime - r.bunTime) / r.npmTime * 100).toFixed(1),
  }));

  await csvWriter.writeRecords(csvData);
  console.log('CSV results written to benchmark-results.csv');

  // Generate HTML report
  await generateHtmlReport(uniqueResults);
}

// Add error handling
runReportGenerator().catch(err => {
  console.error('Failed to generate report:', err.message);
  process.exit(1);
});

# Check Bun cache status
bun install --verbose

# Clear Bun cache (rarely needed)
bun cache rm

# Cache Bun directory in GitHub Actions
- uses: actions/cache@v4
  with:
    path: ~/.bun
    key: bun-cache-${{ hashFiles('**/bun.lockb') }}
    restore-keys: bun-cache-

# Enable Corepack (run once per machine)
corepack enable

# Pin Bun 1.1.0 in package.json
corepack prepare bun@1.1.0 --activate

# Check active package manager version
corepack --version

# Run benchmark on your project
node benchmark-script.js

# Test Bun compatibility
bun install
bun run start

# Fall back to npm if needed
npm install