Bun vs. Node.js
Do you know Bun? Bun is the new JavaScript runtime that has been making waves in the tech world recently, claiming to be better than Node.js. This article will show how to test it using benchmark scores.
In this article, we'll take a look at the new Bun runtime that's been making waves in the tech world lately. We'll discuss what the runtime does and why some developers switch to Bun. We'll also run some benchmarks to see if Bun actually has the fastest runtimes as claimed by the Bun team.
what is runtime
Imagine you have a big box of Legos and you want to build a cool spaceship. You have all the instructions on how to put the parts together, but you need something to actually assemble the spacecraft and make it work. This is where the runtime comes in. The runtime is like a special assistant responsible for building and running your Lego spaceship. This is a procedure that ensures that all the pieces fit together correctly, making sure that the craft does what it's supposed to do.
When you give the runtime instructions, it reads the instructions step by step and starts placing the Lego bricks in the correct positions. It followed the instructions exactly, making sure every piece connected together correctly and everything was done in the right order. Once the spacecraft is built, the runtime also takes care of its job. It powers the ship, activates the engines, and controls all of the ship's functions. It's like a little computer in the spaceship, running all the commands and making sure everything runs smoothly.
In the programming world, runtime is similar. It is a special program that helps run other programs. It reads the program's instructions, executes them step by step, and makes sure everything is working as expected. So, like an assistant that assembles a Lego spaceship, a runtime is a special program that helps build and run other programs correctly. It acts like a smart assistant, making sure everything runs smoothly, just like you'd expect from a LEGO spaceship.
JavaScript runtime
The JavaScript runtime acts like a translator between JavaScript and the computer. When you tell JavaScript to do something, like add two numbers, the runtime listens and understands what you want. It then takes instructions and talks to the computer in a language it understands.
The runtime also handles other important things. It ensures that JavaScript follows the rules and doesn't make any mistakes. It monitors JavaScript as it runs, much like a teacher monitors students to make sure they complete their assignments correctly.
When the runtime talks to the computer and gets a result, it passes it back to JavaScript. It's like the runtime whispers the answer to JavaScript, which can then do something with the answer. Maybe it displays the answer on the screen, or uses it to create a cool animation.
What is Bun
Bun is a JavaScript runtime built from the ground up using the Zig programming language, focusing on fast startup, efficient code execution and a better developer experience. It provides tools and features to optimize and simplify the development of JavaScript applications and is designed to be compatible with the existing JavaScript ecosystem.
When you tell Bun what you want it to do, it listens carefully. It takes your instructions written in a special language called JavaScript and starts executing them step by step. It's like telling a car where you want to go and how to get there. But Bun doesn't just understand JavaScript - it's also very good at making JavaScript code run very fast. It's like having a car engine that makes your car faster than any other car on the road.
Bun is built using a special programming language called Zig. Zig is like a magical tool that allows the person who created the Bun to build it in a very efficient and fast way. With Bun, you can do all kinds of things. You can build websites and applications that work very quickly and smoothly. You can also use the Command Line Interface to run JavaScript and TypeScript files, bundle code together, and even manage your project's dependencies.
Why Bun is faster
Bun runs at impressive speeds due to several key factors:
- **Lightweight Design**: Buns are designed to be lightweight, resulting in a smaller code base and fewer resource requirements. This optimized design allows Bun to provide better performance in terms of speed and memory usage compared to other runtimes.
- **Underlying Implementation**: The Bun runtime is built using Zig, a relatively new low-level programming language. Zig's features enable developers to write code with fine-grained control over memory management and execution, improving runtime efficiency.
- Performance optimization : Bun does not rely on the V8 engine, but uses WebKit's JavaScriptCore, and its excellent performance has been widely recognized. By leveraging this core engine, Bun benefits from optimized execution of JavaScript code, resulting in increased runtime speed.
- Integrated features : Bun provides native tools and features that simplify the development process. It includes a built-in bundler, replacing the need for external tools like Webpack, and a native transpiler that supports writing TypeScript code directly. In addition, Bun integrates a test runner similar to Jest, which can automatically load environment variables without the need to install additional packages like dotenv.
Install Bun Runtime
To install Bun, you can follow these steps: Open your computer terminal or command prompt. Enter the following command in the terminal:
curl -fsSL https://bun.sh/install | bash
This command will start the Bun installation process by downloading the installation script from the Bun official website. Press Enter and allow the installation script to run. It will handle the necessary steps to install Bun and its dependencies on your system and then wait for the installation to complete. This script will take care of all the necessary tasks to ensure that Bun is installed correctly on your computer.
Bun VS Node
In this section, we'll compare Bun and Node and run some benchmarks between the two runtimes.
- Performance : Bun emphasizes faster startup times and runtime performance, leveraging WebKit's JavaScriptCore engine, known for its speed. In contrast, Node.js relies on the V8 engine, which is also highly optimized but may have performance differences compared to JavaScriptCore.
- Size and Dependencies : Bun strives to be a lightweight runtime, with a smaller code base and minimal dependencies. It integrates built-in tools like packagers and transpilers, reducing dependence on external dependencies. In comparison, Node.js is a more comprehensive runtime with a larger code base and extensive support for external modules and libraries.
- Compatibility : Although Bun is intended as a drop-in replacement for Node.js, there may be differences in API compatibility. Although Bun implements many Node.js and Web APIs natively, some specific Node.js modules or APIs may not be fully supported.
- **Tools**: Bun provides an integrated toolkit for JavaScript development, including bundlers, transpilers, and package managers. Node.js, on the other hand, has a rich ecosystem of third-party tools and libraries for various development tasks, such as popular bundlers like Webpack and package managers like npm or Yarn.
- Community and Ecosystem : Node.js benefits from a mature and broad community with extensive support, well-documented resources, and a large ecosystem of modules and libraries. In comparison, Bun is relatively new and likely has a smaller community and a more centralized ecosystem.
Benchmarks
This benchmark test was run on my computer, and the data may deviate from your own tests. For the benchmarking tool, we will use Grafana Labs’ open source tool k6 . You can find the installation guide for the tool here .
For our code, I obtained a simple HTTP server code from Bun and Node.js official website. Below is the code of Hello World in Bun and Node.
- Node
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}/`);
});
Run the command on the terminal:
node server.js
Your node server will run on port: http ://localhost:3000/
- Bun
export default {
port: 3001,
fetch(_) {
return new Response("Hello World");
},
};
Your Bun server will run on port: http ://localhost:3001/
Run the command on the terminal:
bun run bunserver.js
Create a script.jsfile and paste this test script:
import http from 'k6/http';
import {
sleep } from 'k6';
export default function () {
http.get('http://localhost:3001/'); // 这将根据你测试的服务器而变化
sleep(1);
}
In your terminal run:
k6 run script.js
Here are the results from our Node server:
Here are the results from our Bun server:
Now we can see and compare the speed of Bun and Node. If you want to take it a step further, you can introduce different delays, more users and durations into your script:
k6 run --vus 10 --duration 30s script.js
summary
In summary, Bun and Node.js are two JavaScript runtimes that provide developers with different methods and features. Bun focuses on a lightweight design that provides fast startup times, optimized performance, and integrated tools such as packers and transpilers. It leverages WebKit's JavaScriptCore engine to achieve its performance goals. Node.js, on the other hand, has a larger ecosystem, extensive community support, and compatibility with multiple programming languages. It relies on the V8 engine and provides a wealth of third-party tools and libraries. The choice between Bun and Node.js depends on factors such as performance requirements, specific project needs, availability of suitable tools and community support. Ultimately, developers can take advantage of each runtime to build robust and efficient JavaScript applications.