Bun: The JavaScript runtime taking over Node.js and Deno

Bun is a brand new, blazing quick JavaScript runtime that has everybody speaking. To grasp why Bun is such an enormous deal, let’s first evaluate some vital JavaScript historical past.

What’s a JavaScript engine?

When JavaScript was first created, it solely ran in browsers, initially Netscape Navigator. Nonetheless, builders wanted software program that would learn JavaScript code and switch it into one thing that would run on the pc. This expertise is called the JavaScript engine. On the time of writing, there are three predominant JavaScript engines that energy your favourite browsers:

• V8: Created by Google for Chrome
• SpinderMonkey: Created by Mozilla for Firefox
• JavaScriptCore: Created by Apple for Safari

Every JavaScript engine has its personal minor variations in its help for the JavaScript spec, how shortly it adopts new JavaScript options, and its ease of use and efficiency.

Introducing JavaScript runtimes

Ultimately, in 2009, Ryan Dahl first started to develop a instrument that may permit JavaScript to run outdoors of the browser. When selecting an engine to construct this instrument round, he selected V8.

What he created was a JavaScript runtime, a instrument for operating JavaScript outdoors of the browser. It gave JavaScript entry to your broader pc community and file methods for creating internet servers and any sort of utility you’ll be able to consider.

Node.js has since exploded in recognition, changing into a go-to instrument in frontend and backend internet growth. When Node.js was created, many trendy JavaScript requirements didn’t exist but, just like the Fetch API, ES modules, and extra.

Seeing the expansion of TypeScript and the robustness of internet requirements, Ryan Dahl created a successor to Node.js utilizing Rust, referred to as Deno. Deno supplied velocity enchancment, an embrace of internet requirements, and first-class help of TypeScript and JSX.

What’s Bun?

In 2022, former Stripe developer Jared Sumner launched Bun. Bun is a runtime developed within the Zig programming language, which additionally embraces internet requirements however goals for compatibility with Node.js APIs, so builders can simply migrate current code.

One of the crucial fascinating decisions is that Bun makes use of the JavaScriptCore as its engine, in contrast to Node.js and Deno, which use V8. The result’s a blazing quick runtime that additionally presents a number of high quality of life options for JavaScript builders.

Bun additionally has first-class integration of TypeScript and JSX. It goals to supply lots of the options of transpilers, like Babel, and Bundlers like Webpack, Rollup, Snowpack, and Vite.

Taking Bun for a take a look at drive

To get began with Bun, first, we’ll have to put in it. In accordance with the Bun documentation, set up requires solely the next command:

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

Have in mind, this command will solely work on Mac and Linux. So, if you happen to’re utilizing Home windows, you’ll must arrange Window Subsystem for Linux to put in Bun.

As soon as it’s finished putting in, be certain to learn the affirmation immediate with instructions for including Bun to your PATH. It would require you so as to add the next strains to your .bashrc or .zshrc information:

BUN_INSTALL="/dwelling/<username>/.bun"
PATH="$BUN_INSTALL/bin:$PATH"

Now, if you happen to run bun--version, it’s best to get a model quantity printed confirming you’ve gotten put in it appropriately.

Writing and operating our first Bun script

Create a file referred to as script.js and add the next code inside it:

Bun.serve({
    fetch(request){
        return new Response("Whats up World")
    }
})
console.log("Listening on Port 3000")

Bun.serve initiates the server and takes an object with the server configurations. On every request, the request object is handed to a operate saved because the fetch property on the configuration object.

We will run Bun.serve through the use of the command bun run script.js after which going to localhost:3000 to see the response to our request. If we needed to vary which port it would serve on, we are able to add a port property to the item handed to Bun.serve.

Writing information with Bun

Bun has a reasonably easy API for writing to information. Let’s modify our script to jot down to a file every time we submit a request:

let rely = 1
Bun.serve({
    fetch(request){
        Bun.write(`${rely}.txt`, request.url)
        rely += 1
        return new Response("Whats up World")
    },
})
console.log("Listening on Port 3000")

Run the code above and go to localhost:3000/cheese, and also you’ll see two new information created, 1.txt and 2.txt. The primary argument of Bun.write is the goal of the write, like a file or stdout, and the second argument is what to jot down.

In-built help for SQLite3

Not like different JavaScript runtimes, you don’t have to put in SQLite3 as a result of it’s in-built out of the field. Let’s create a brand new file referred to as db.js with the next code:

import { Database } from "bun:sqlite";
// Create a brand new Database File
const db = new Database("db.sqlite3");
// Create a desk within the database
db.run("CREATE TABLE IF NOT EXISTS cheeses (title VARCHAR(100));")
// Insert Some Values into the desk
db.run("INSERT INTO cheeses VALUES ('gouda'), ('munster'), ('brie');")
// Question the desk
const outcome = db.question("SELECT * FROM cheeses;").all()
// Log outcomes
console.log(outcome)

Run the code with bun run db.js, and it’s best to see the information which can be inserted logged on the terminal.

Utilizing .env information with Bun

One other very nice contact is the flexibility to make use of .env information out of the field. You’ll be able to merely entry them with course of.env like in Node.js while not having to put in any libraries. Create an .env file with the next command:

VARIABLE=cheddar

Now, let’s replace our script.js with the next code:

// let rely = 1
Bun.serve({
    fetch(request){
        // Bun.write(`${rely}.txt`, request.url)
        // rely += 1
        return new Response(course of.env.VARIABLE)
    },
})
console.log("Listening on Port 3000")

Now, once we run bun run script.js and go to localhost:3000, we must always ought to see the data from our .env file being returned.

Conclusion

Past being tremendous quick, Bun has some very good options that make lots of the extra mundane duties like writing information, managing easy databases, and utilizing environmental variables fairly straightforward.

Will Bun overtake Deno and problem Node.js for its throne? We’ll have to attend and see. Bun will a minimum of, like Deno, showcase many inventions that Node.js can undertake whereas carving out an area of its personal.

Both approach, it’s an enormous win for JavaScript builders in every single place to have one other runtime within the area. On the time of writing, Bun remains to be early in its growth with many APIs and options not but carried out. Nonetheless, what is accessible to date is kind of spectacular, so it’s value maintaining with.

Remember to try this video of my first take a look at run of Bun and go away a remark when you’ve got any questions. Completely satisfied coding!