2024 JavaScript Promise Performance Comparison

This article was inspired by the following article:

2021 JavaScript Promise Performance Comparison

https://blog.skk.moe/post/promise-performance-benchmark

In the “2021 JavaScript Promise Performance Comparison” article, Sukka provided a detailed performance comparison of JavaScript Promises and concluded that “Bluebird remains the fastest Promise implementation with the least memory usage”.

Building on this foundation, this article compares the performance of JavaScript Promise in 2024, examining whether Node’s native Promise performance has improved over the years and how the emerging Bun’s Promise implementation performs?

Benchmark

The Benchmark Suite used in the test comes from Sukka’s Fork version based on modifications by the v8 team:

promise-performance-tests

https://github.com/sukkaw/promise-performance-tests

The test environment is:

OS: Windows_NT 10.0.22631 x64
CPU: 13th Gen Intel(R) Core(TM) i5-13400F x 16
Memory: 32581.421875 MiB

Bluebird vs Native Promise

Sequential Execution

Sequential Promise execution has mutual dependencies or strict timing logic between Promises, and cannot be executed in parallel. In doxbee, the following code is used to simulate sequential execution in daily development:

Promise.all([blobPromise, filePromise])
  .then(([blobId, fileV]) => {
    // Do something
    // For example, insert blobId and fileV into database
  })
  .then(() => {
    // Do something
    // For example, do a query for fileIdV
  })
  .then((fileIdV) => {
    // Do something
    // For example, insert fileIdV into database
  })
  .catch((err) => {
    // Catch error
  });

try {
  const [blobId, file] = await Promise.all([blobPromise, filePromise]);
  // Do something
  await DoSomething(blobId, file);
  // Do something
  await DoSomething(tx);
  // Do something
  await DoSomething({
    fileId,
    versionId: version.id,
  });
} catch (err) {
  // Catch error
}

From the charts, it can be seen that Promise BlueBird performs better than Promise native in both performance and memory usage during sequential execution, while Async/Await Bluebird is inferior to Async/Await Native in both performance and memory usage. Overall, native Async/Await is optimal for sequential execution.

Parallel Execution

Parallel Promise execution has no mutual dependencies between Promises and can be executed in parallel. In doxbee, the following code is used to simulate parallel execution in daily development:

Promise.all(queries) // queries is an array of lots of promises
  .then(() => {
    // Do something
    // For example, commit transaction
  })
  .catch((err) => {
    // Catch error, and rollback transaction
  });

try {
  await Promise.all(queries); // queries is an array of lots of promises
  await DoSomething(); // For example, commit transaction
} catch (err) {
  // Catch error, and rollback transaction
}

Similar to sequential execution, Promise BlueBird performs better than Promise native in both performance and memory usage during parallel execution, with speed 4 times faster and memory usage 7 times less (though the gap on Bun is not as large). While Async/Await Bluebird is inferior to Async/Await Native in both performance and memory usage (except on Bun). Overall, if you use Promise, BlueBird is better; but if you use Async/Await, native Async/Await is better.

Native Promise vs JavaScript Promise

The Promise implementations participating in Benchmark include:

• Bluebird
• core-js
• es6-promise@npm
• es6-promise-polyfill@npm
• promise@npm
• Q.js
• SPromiseMeSpeed
• Zousan

Sequential Execution

Bluebird is optimal in both performance and memory usage.

Parallel Execution

Bluebird remains the most excellent Promise implementation.

Conclusion

• Bluebird remains the fastest JavaScript Promise implementation with the least memory usage.
• As Node.js versions update, native Promise performance has improved, but there is still a certain gap compared to Bluebird. However, Async/Await performance and memory usage have surpassed Bluebird.
• Bun’s Promise performance is similar to Node.js 22.
• As written in Bluebird’s README: Please use native promises instead if at all possible. Today, native Promise is already good enough. However, if you need to use Promise Polyfill or need additional APIs provided by Bluebird, then Bluebird remains the optimal choice.