Is Bun so much faster than Node.js?

It seems like Bun is the new cool kid in the javascript runtime scenario. Looks very promising and all of that, but, is it that fast?

I will do a set of simple tests, to see if even on a small scale the performance difference is already noticeable.

Today I will focus only on requests performance and operations per second.

Setting up Bun

But first, I'll start installing bun in the bun directory

curl https://bun.sh/install | bash

And creating a basic response

// http.js
export default {
  port: 3000,
  fetch(request) {
    return new Response("Welcome to Bun!");
  },
};

Setting up node

Now I can move on to node. Because I already have Node.js installed I just have to create a basic response as well.

const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Now I'm ready to have fun.

Http request performance

For the HTTP request performance, I'll test both implementations using Artillery.

Artillery can be installed through npm

npm i artillery

And comes with a nice CLI to execute a quick load test.

 artillery quick --count 500 --num 100 http://localhost:3000

This will run 500 virtual users with 100 requests each.

The results are the following:

(in milliseconds)

The results are far from the claims in performance from Bun, but still, very solid. In all aspects, Bun stands out as the winner.

Operations per second

Here I'll do a test of just calculating prime numbers, to see how long it takes for each one.

To test the calculation of prime numbers I will execute a very simple code and make use of performance.now() to measure the execution time.

(function (maxNumbers = 30000) {
  let start = performance.now();
  let primeNumbers = []
  let numberToCheck = 1;
  while (primeNumbers.length < maxNumbers) {
    if (isPrimeNumber(numberToCheck)) {
      primeNumbers.push(numberToCheck);
    }
    numberToCheck++;
  }

  console.log(performance.now() - start);
})();

function isPrimeNumber(number) {
  for (let i = 2; i < number; i++) {
    if (number % i === 0) return false;
  }
  return true;
}

The results for calculating prime numbers are the following (in milliseconds):

This time the results are not that different, but Bun wins again.

Bun is still in beta version, and we should keep that in mind. If at this stage the results already look promising, interesting times will come if the improvement continues along the same lines and, who knows, maybe in some years Bun will find its place on the market.