Modern Javascript Landscape

The javascript landscape finds itself in a perfect storm where if you take a look at all of the actors involved it is certainly encouraging to be a JS oriented developer. Given frontend solutions naturally involve browsers, mobile (though JS is not necessarily a first choice there) and other devices, you would think it is always the case that it is encouraging. I am referring specifically to the growing list of competitors and alternatives to Node. 

The javascript world has always been a competitive environment. You have always been able to choose from a wide variety of frameworks and libraries for UI concerns and in the near future this will change for other paradigms as well. The focus of this article is to bring attention to some of the newer players – Deno and Bun – and how Node is trying to keep up, which is all a big win if you are still looking for ways to leverage JS expertise into other areas without needing to sacrifice for transition time to other technology stacks.

First Impressions

We will have a non-FE point of view and focus on the following factors: developer experience, security, performance, typescript support and dependencies.

Node 24

The current Node release is version 24 and it was released this year in May. In terms of DevEx, Node hasn't changed much. If you have kept your stack updated then you might've noticed that npm is faster and node as a whole has been considering a wide array of security concerns, from the permission model (explicit permissions to system APIs) to stuff like npm audit which help manage the hard task of keeping your dependencies up to date and not open to vulnerabilities. In terms of performance, just updating Node to the latest current version should land you some noticeable performance bumps, thanks to V8 engine updates and also core standard library changes. 

We might also be reaching a time when we no longer need a separate cli tool to run typescript like ts-node or tsx, since Node 23 the experimental flag --experimental-strip-types allows you to ignore types and run ts directly. While it’s not direct typescript support we can treat typescript as just a typehint and checking framework along with a tsconfig file, without that stopping us from running the code or needing to transpile it first. Node 24 now also ships with its own test runner so that you can avoid requiring external testing frameworks.

Deno

Deno is one of the modern javascript runtimes, its aim is to offer a complete solution. Deno v1.0 was released in May 2020. Like Node it is also based in the V8 engine but it ships with everything you can think of: dependency manager, typescript support (not just type stripping but it actually understands it), data storage, key security features, limited interoperability with existing "node projects" and a whole set of tooling: REPL, built-in formatter and linter, test runner, debugger and compile js or ts into executables (although this is considered an unstable feature). 

As for performance, Deno should offer an edge when compared to Node, we will prove this in the following section. Deno was co-created by Ryan Dahl which was also the case for Node and its development is run by the Deno Company. Deno already boasts in its portfolio some known organizations: Netlify, Slack, Supabase and Bank of America.

Bun

Bun (v1, released in September 2023) sells itself as an "all in one javascript runtime and toolkit", its stated design objectives are: speed, elegant APIs (highly optimized apis, so faster) and cohesive developer experience, meaning you have everything you need to work. On the surface Bun and Deno appear to be the same thing but they aren't. Deno clearly is very concerned with security and overall being a modern JS runtime, fixing what it sees as flaws in Node, it even avoids the dreaded node_modules dir. Bun on the other hand is a completely different approach where speed and being a drop-in replacement for Node are the main concerns. 

When using Bun for the first time, it is pleasantly surprising how easy it is to get started if you are just probing for a possible project migration or starting a new project while speed and performance certainly being significantly much better than Node. Among Bun's users we can find Anthropic, Midjourney and X. Its typescript support is similar to Node's, it runs it by stripping types but you still rely on your IDE or typescript to do the type-checking. Bun also uses a different engine, JavascriptCore (webkit and safari) instead of V8.

Performance Comparisons

There are many benchmark tests out there that compare Node, Deno and Bun. We decided to make our own to see how it would compare to the other sources out there. The following results are based on an express + node/deno/bun implementation where we use 2 endpoints POST /forms which simulates payload processing and writing to a database table forms and GET /forms which fetches all of the records available in forms. This is the test script for node:

// server.ts

import express from 'express';

import { DatabaseSync } from 'node:sqlite';

import { faker } from '@faker-js/faker';

const db = new DatabaseSync('express.db');

db.exec('DROP TABLE IF EXISTS forms');

db.exec(`

  CREATE TABLE IF NOT EXISTS forms (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    value_one TEXT,

    value_two TEXT,

    value_three TEXT

  );

`

);

interface PostForm {

  value_one: string;

  value_two: string;

  value_three: string;

};

const insertForm = (values: PostForm) => {

  const { value_one, value_two, value_three } = values;

  db.prepare('INSERT INTO forms (value_one, value_two, value_three) VALUES (?, ?, ?);')

  .run(value_one, value_two, value_three);

}

const getForms = () => {

  return db.prepare('SELECT * FROM forms;')

  .all()

}

const server = express();

server.get('/', (_, res) => {

  res.send({ ok: true });

});

server.post('/forms', (_, res) => {

  // simulate a payload

  const values = { value_one: faker.word.preposition(), value_two: faker.word.adjective(), value_three: faker.word.noun() };

  insertForm(values);

  res.status(201).send({ created: true });

});

server.get('/forms', (_, res) => {

  res.send({ results: getForms() })

});

server.listen(3000);

console.log('Server is listening on port 3000');

In the case of Deno and Bun the script looks very similar but the way in which we install and import dependencies is different. In the case of Deno I had to include a @ts-types annotation // @ts-types="npm:@types/express@5.0.3" while running deno as deno run --allow-net --allow-env --allow-read --allow-write server.ts which is expected of Deno's security model. Dependency installs are similar to npm but there are a few workarounds to use node modules like deno install npm:express. In the case of Bun it was more of a familiar path: bun install and bun server. Finally, we ran tests using apache benchmark and running 10000 requests at a max concurrency of 1000.

Results

Time taken for tests (Lower is better)

“POST /forms”

“GET /forms”

Complete Requests (Higher is better)

“POST /forms”

“GET /forms”

Requests Per Second (Higher is better)

“POST /forms”

“GET /forms”

Time Per Request (Lower is better)

“POST /forms”

“GET /forms”

Longest Request (Lower is better)

“POST /forms”

“GET /forms”