A rival JavaScript runtime contender has entered the fight between Node.js and Deno. On this article, we take a primary have a look at Bun, and the explanations it will tempt you away out of your present favourite.

Ryan Dahl launched Node.js in 2009. It wasn’t the primary server-side JavaScript runtime, however Node.js abruptly won momentum. Model 20 arrived in 2023, and Node.js has the biggest building ecosystem, with 3.2 million modules — accounting for nearly 500 billion downloads every week (in keeping with npmjs.com).

In 2020, Ryan Dahl launched Deno — a remix of “noDe” — to modernize JavaScript building and deal with legacy problems with Node.js safety, API compatibility, tooling, and module control. Reception has been certain, even if Deno is but to problem Node’s domination.

In 2022, Jarred Sumner launched Bun following his frustrations with the rate of Node.js when growing a Subsequent.js mission. The foundation of the identify is unclear, and the brand doesn’t lend a hand! It would relate to the meals, fluffy rabbits, “package deal”, or in all probability it’s a brief, memorable identify and the bun.sh area was once to be had.

The aim: Bun will grow to be a drop-in alternative for Node.js, Deno, serverless JavaScript, and equipment equivalent to webpack, Babel, and Yarn. Somewhat than operating npm beginning to release your Node script, you’ll be able to run bun beginning and profit from Bun’s pace.

Tasty Bun Advantages

Node.js and Deno use Chrome’s V8 JavaScript engine. Bun opts for the JavaScriptCore engine which powers WebKit browsers equivalent to Safari. Bun itself is written in Zig — a low-level programming language with handbook reminiscence control and local threading to care for concurrency. The result’s a light-weight runtime with a smaller reminiscence footprint, faster start-up instances, and function which will also be 4 instances sooner than Node.js and Deno below sure (benchmarking) stipulations.

Like Deno, Bun has local beef up for each JavaScript and TypeScript with out requiring a third-party transpiler or configuration. It additionally helps .jsx and .tsx recordsdata to transform HTML-like markup to local JavaScript. Experimental beef up for operating WebAssembly-compiled .wasm recordsdata is to be had.

Internally, Bun makes use of ES Modules, helps top-level wait for, interprets CommonJS, and implements Node’s node_modules answer set of rules. Bun caches modules in ~/.bun/set up/cache/ and makes use of hardlinks to replica them right into a mission’s node_modules listing. All initiatives to your gadget will subsequently reference a unmarried example of the similar library, which reduces diskspace necessities and improves set up efficiency. (Word that macOS installations retain native variations for pace.)

Bun helps Node’s bundle.json, npm an identical instructions, and bunx — a npx-like approach to auto-install and run applications in one command. For instance:

bunx cowsay "Hi, global!"

bun init scaffolds empty initiatives in the similar means as npm init, however you’ll be able to additionally template a brand new mission with bun create <template> <vacation spot>, the place <template> is an reputable bundle, a Github repository, or a neighborhood bundle. For instance, to create a brand new Subsequent.js mission:

bun create subsequent ./myapp

Bun features a bundler to import all dependencies right into a unmarried document and will goal Bun, Node.js, and client-side JavaScript. This reduces the want to use equipment equivalent to esbuild or Rollup:

bun construct ./index.ts —outdir ./out

Maximum command-line interface choices are to be had by the use of a JavaScript API, so it’s imaginable to create subtle construct scripts and not using a devoted job runner. Right here’s an equivalent construct to the command above:

wait for Bun.construct({
  entrypoints: ['./index.ts'],
  outdir: './out',
})

Bun has a normal take a look at runner like Deno and Node.js 20. Operating bun take a look at executes scripts named like this:

*.take a look at.ts
*_test.ts
*.spec.ts
*_spec.ts

There’s little need for nodemon-like equipment, since bun has a —watch flag which restarts scripts or assessments whilst you alter a dependency document. Restarts are so speedy that it turns into imaginable to live-reload on each and every keystroke. (Whether or not that is sensible and now not a distraction is any other subject!)

Are living reloading isn’t beautiful! (Caution: flickering content material!) View unique animated GIF.

A equivalent —scorching mode is to be had, the place Bun watches for adjustments and cushy reloads modules. All recordsdata are re-evaluated, however the world state persists.

Setting variables contained in mission .env recordsdata are robotically loaded and parsed, making them to be had in Bun programs, so there’s no want to use applications equivalent to dotenv.

In addition to its personal Bun APIs for networking, document get entry to, kid processes, and so forth, Bun helps:

• Internet APIs equivalent to fetch, URL, blob, WebSocket, JSON, setTimeout, and occasions.

• Node.js compatibility APIs equivalent to console, assert, dns, http, trail, flow, and util, in addition to globals together with __dirname, and __filename. Bun claims that 90% of the most-used APIs are totally applied, even if you must double-check the ones particular for your mission.

In the end, Bun has a local SQLite3 Jstomer — bun:sqlite — which might scale back the choice of dependencies required in some initiatives.

Underbaked Bun

Bun is in lively building, so the next options are but to look:

• a Deno-like permission style to limit get entry to to recordsdata, the community, kid processes, surroundings variables, OS data, and so forth. Including permission rights later may cause headaches (as observed in Node.js 20), so I think choices will arrive earlier than the model 1.0 liberate.

• Equipment equivalent to a Learn-Eval-Print Loop (REPL), dependency inspector, linter, debugger, code formatter, documentation generator, and a standalone script generator are lacking however must seem through the years.

Putting in Bun

Bun has now not reached a model 1.0 liberate, however it’s to be had as a unmarried binary you’ll be able to set up on Linux, macOS, and Home windows WSL with:

curl -fsSL https://bun.sh/set up | bash

Then again, you’ll be able to set up it with Node’s bundle supervisor:

npm set up -g bun

A local Home windows model is coming, even if the Home windows Subsystem for Linux is continuously the simpler and better-performing possibility. Then again, you’ll be able to additionally use Docker to run Bun in a container:

docker run —rm —init —ulimit memlock=-1:-1 oven/bun

As soon as put in, you’ll be able to improve the engine with:

bun improve

To uninstall, take away the ~/.bun binary and cache listing:

rm -rf ~/.bun

Then replace your shell configuration document (.bashrc, .zshrc, or equivalent) to take away ~/.bun/bin references from the $PATH variable.

The use of Bun

Bun is dependable for those who use it from the beginning of your mission. Velocity is best than Node.js, even if you’re not going to look a vital efficiency spice up until your app is doing particular in depth duties such heavy SQLite processing or WebSocket messaging.

Node.js compatibility is excellent for smaller, more practical initiatives, and I effectively introduced some scripts the use of bun beginning with out making adjustments. Extra advanced programs did fail, with difficult to understand error messages generated deep within the node_modules hierarchy.

Bun vs Deno vs Node.js

Deno addressed lots of Node’s drawbacks, however builders didn’t essentially really feel pressured to modify:

1. Deno didn’t beef up Node’s third-party modules.
2. Migrating from Node.js to Deno required studying new tactics.
3. Whilst Deno presented a greater building enjoy, Node.js was once excellent sufficient.

Deno has now added Node.js compatibility choices. That was once the best way to get builders to transition to Deno, however within the intervening time, Node.js has followed a few of Deno’s options, together with ES modules, a local take a look at runner, and a —watch mode.

Bun has taken a unique way, aiming to be a quick, Node-compatible engine with Deno’s developments. The indicators are promising, however it’s now not there but:

• Efficiency is superb, however few builders bitch about Node.js pace.

• Compatibility is excellent, however it’ll be a problem to beef up all Node.js modules in a unique JavaScript engine. Can JavaScriptCore stay alongside of V8 tendencies with a ways much less funding?

• Bun has the possible to exchange your tooling suite, however it’s but to provide the overall vary present in Deno.

Abstract: Must You Transfer to Bun?

Bun is an completed JavaScript runtime, however Node.js stays the champion for mission-critical initiatives or legacy programs. You must check out operating your app the use of bun beginning, however the better your codebase, the fewer probability it’ll execute with out amendment.

Deno is almost definitely a better choice than Bun for brand new initiatives, for the reason that it’s extra mature and feature-complete.

Bun is superb, however it’s new, being actively advanced, and but to succeed in a model 1.0 milestone. The runtime is strong, however few would guess on its long-term long term at this level. That stated, Bun has some fascinating concepts which I’m hoping each the Node.js and Deno groups imagine adopting (CLI APIs and auto-loaded .env please!)

On a facet notice, I really like Bun’s identify, however it may be tricky to seek for assets. ChatGPT makes the daring observation that “There’s no well known JavaScript runtime referred to as ‘Bun’. So far as I’m conscious, there is not any such generation within the JavaScript ecosystem.” This can be as a result of post-2021 information is proscribed, even if sure questions go back a Bun reaction and an apology for the error!

I think we’re heading towards an age of isomorphic server-side JavaScript, the place module builders try to write code that’s well suited with all runtimes: Node.js, Deno, Bun, serverless, edge, embedded, and many others. We might sooner or later achieve some extent the place JavaScript runtimes are most commonly interchangeable in the similar means browsers are as of late.