计软杂谈

This article was inspired by the following article:

2021 JavaScript Promise Performance Comparison
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 2025, examining whether Node’s native Promise performance has improved over the years and how the emerging Bun’s Promise implementation performs?

I also compared JavaScript Promise performance in 2024:

2024 JavaScript Promise Performance Comparison
2024 JavaScript Promise Performance Comparison
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
promise-performance-tests
https://github.com/sukkaw/promise-performance-tests

The test environment is:

1
2
3
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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
  });
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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, the following can be observed in sequential execution scenarios:

  • Performance: In Node.js 24 and 25, Promise BlueBird and Async/Await native achieve the best performance, taking around 10-11ms. Compared to Node.js 20, performance improvement is significant (from 17-22ms to 10-12ms).
  • Memory Usage: Async/Await native consumes the least memory on Node.js 22 (0.978 MiB). Overall, native Async/Await shows excellent memory performance.
  • Bun Performance: Bun 1.3.1’s Async/Await native performs well (18.628ms), but Promise native performance is relatively poor (27.201ms).

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:

1
2
3
4
5
6
7
8
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
  });
1
2
3
4
5
6
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
}

From the parallel execution test results, the following observations can be made:

  • Performance: Promise BlueBird performs excellently across all versions, taking only 8-10ms. Node.js 24/25’s Async/Await native also shows significant performance improvement (from 40-43ms to 17-24ms).
  • Memory Usage: Promise BlueBird’s memory usage increases on Node.js 24/25 (3.5-3.8 MiB), but still maintains a relatively low level. Native implementations show significantly reduced memory usage after Node.js 22.
  • Performance Gap: In parallel execution scenarios, Promise BlueBird’s advantage over native Promise is more pronounced, being 2-4 times faster.
  • Bun Performance: Bun has good memory performance, but Async/Await native performance (47.495ms) is slightly inferior to the latest Node.js versions.

Native Promise vs JavaScript Promise

The Promise implementations participating in Benchmark include:

Sequential Execution

Comparing various Promise implementations in sequential execution scenarios:

  • Callback Baseline: Native Baseline represents the performance baseline of traditional callback methods (3.694ms, 0.079 MiB), serving as a reference.
  • Bluebird Optimal: Among all Promise implementations, Bluebird performs best (10.687ms, 0.797 MiB) with significantly better performance and memory usage compared to other Promise libraries.
  • Other Implementations: SPromiseMeSpeed (13.046ms) and npm-es6-promise-polyfill (12.448ms) perform well, while Q.js (28.081ms) and Zousan (29.916ms) have relatively poor performance.

Parallel Execution

Comparing various Promise implementations in parallel execution scenarios:

  • Callback Baseline: Native Baseline represents traditional callback methods (2.823ms, 0.060 MiB), which is optimal in both performance and memory, as expected.
  • Bluebird Leading: Among all Promise implementations, Bluebird has the best performance (8.171ms, 3.586 MiB), with speed approximately 3 times that of callbacks, but with notably increased memory usage.
  • Massive Performance Gap: There is a huge gap between different Promise implementations, with npm-es6-promise performing worst (228.346ms), nearly 28 times slower than Bluebird.

Conclusion

  • Bluebird remains the fastest Promise implementation: Among all Promise libraries, Bluebird maintains a leading position in both performance and memory usage.
  • Node.js native Promise continues to optimize: As Node.js versions update, native Promise performance shows significant improvement. In Node.js 24/25, Async/Await native performance in sequential execution scenarios is already very close to Promise BlueBird.
  • Clear performance gap in parallel execution scenarios: In scenarios where large numbers of Promises are executed in parallel, Bluebird’s advantage over native Promise and other third-party libraries is more pronounced, with performance 2-4 times faster.
  • Bun’s performance is moderate: Bun 1.3.1’s Promise performance and memory usage are similar to Node.js 20/22, with good Async/Await performance, but overall still has a gap compared to the latest Node.js 24/25.
  • Usage Recommendation: As written in Bluebird’s README: Please use native promises instead if at all possible. For most application scenarios, native Promise/Async-Await is already sufficiently good. However, if your application needs to handle large numbers of parallel Promise operations, or needs the additional APIs provided by Bluebird (such as Promise.map, Promise.props, Promise.each and other utility methods), then Bluebird remains the optimal choice.

Leave a comment

waline