Introduction

In my previous article, I wrote about Hono, and following that, I recently started learning about a new JavaScript runtime called Bun. Until now, it has been common to use Node.js for backend development, so learning about this new runtime, Bun, has felt very refreshing.

Although I am still a beginner and my understanding may not be complete, I wanted to share this as a personal note and as a resource for others who might be interested in Bun but have not yet explored it much. While the content may lack some details, I hope you find it informative and inspiring.

What is Bun?

Bun is a new JavaScript and TypeScript runtime that developed in 2022, serving as a platform for running JavaScript on the server-side, similar to Node.js and Deno. Because of this, it has gained attention as a potential competitor or alternative to these existing runtimes.

However, Bun is not just a simple replacement for Node.js. It is a multifunctional toolkit designed to handle the entire JavaScript workflow — from development, testing, and execution to bundling — all within a single tool. This comprehensive approach sets Bun apart, providing a more integrated solution for a wide range of development needs compared to other runtimes.

Moreover, as a newer player, Bun leverages its late entry to the market by incorporating significant optimizations in terms of performance and speed. Specifically, it aims to outperform existing runtimes in areas like module loading and script execution speed. For example, Bun natively supports TypeScript and minimizes the need for transpilation, offering a more efficient development environment.

Thus, Bun positions itself as more than just a "server-side JavaScript runtime"; it aims to be a next-generation tool that covers the entire development process. In the future, with increased adoption by the developer community and the continued growth of its ecosystem, Bun has the potential to make a significant impact on the landscape of JavaScript runtimes.

Tip: Definition of a JavaScript Runtime

A JavaScript runtime broadly refers to an environment that allows JavaScript or TypeScript to be executed. This enables JavaScript to run in various contexts, including in the browser, on server-side platforms, and in command-line tools.

Typically, JavaScript runs inside browsers like Chrome or Firefox, using their built-in JavaScript engines (e.g., the V8 engine in Chrome and SpiderMonkey in Firefox). This makes browsers the primary runtime environment for JavaScript, allowing it to be executed only within the browser itself.

However, JavaScript runtimes like Node.js, Deno, and Bun are built on these engines and extend them to enable JavaScript to run outside of the browser. They add additional features to these engines, making it possible to use JavaScript in broader applications such as server-side programs, automation scripts, and command-line interface (CLI) tools.

As a result, JavaScript can be used not only for front-end development but also as a powerful option for back-end development and other areas, establishing itself as a versatile scripting language that goes beyond the boundaries of traditional web development.

In this way, a JavaScript runtime is not limited to just browser execution; it can operate in a variety of environments, making it suitable for many different types of development.

Setup

In this article, I’ll be walking you through the initial setup steps as an introduction.

1. Installation

Let's start by installing Bun. Simply run the following command in your terminal to set it up:

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

After the installation is complete, use bun -v to check the version and ensure that it was successfully installed.

2. Creating a New Project

When starting a new project, use the bun init command. By running the following command, a basic setup will be automatically created for you:

bun init my-app
cd my-app

3. Building a Simple Server

Next, let’s build a simple server using Bun. Save the following code as index.ts, and then run bun run index.ts to start the server:

import { serve } from "bun";

serve({
  fetch(req) {
    return new Response(“Hola, Bun!");
  },
  port: 3000,
});

console.log("Server is running at http://localhost:3000");

When you access http://localhost:3000 in your browser, you should see "Hola, Bun!" displayed!

Tip: TypeScript

As you might have noticed from the setup steps above, Bun natively supports TypeScript and JSX, allowing you to use TypeScript and JSX without needing a separate transpiler (as demonstrated by using the index.ts file in our example). This is currently one of my favorite features of Bun.

In contrast, Node.js cannot directly run TypeScript. To use TypeScript in Node.js, you need to convert .ts files into .js files using some method, such as ts-node or compiling them with tsc. While you can set up TypeScript in Node.js with these tools, Bun’s ability to run TypeScript directly makes development much more convenient and straightforward.

Conclusion

In this article, I covered the initial setup of Bun and demonstrated how to create a simple sample application. While the content was introductory and may have felt somewhat basic, I hope it provided a good overview of Bun’s core features and usage.

In more advanced projects, you’ll likely encounter scenarios where you compare Bun with other established JavaScript runtimes like Node.js. As for myself, I’m still in the process of experimenting with Bun, especially in terms of its performance and potential advantages over traditional runtimes.

Moving forward, I plan to continue exploring Bun further. If I discover any new insights or use cases, I’ll be sure to share them in future articles. Thank you for your continued support, and I look forward to sharing more updates!