QuickBEAM: JavaScript Runtime Inside Erlang's BEAM VM

QuickBEAM just landed on Hacker News with 83 points: a JavaScript runtime that executes JS code directly inside the BEAM (Erlang's virtual machine — the engine behind WhatsApp, Discord, and telecom systems famous for 99.9999999% uptime). This matters because JavaScript, for all its popularity, has always struggled with the one thing Erlang solved decades ago: what happens when your code crashes at 3am.

The project, hosted at github.com/elixir-volt/quickbeam, is a "Show HN" submission from the Elixir Volt team — and it's generating real discussion because it bridges two worlds that have always stayed separate: the enormous JavaScript ecosystem and the industrial-strength reliability of Erlang.

Why JavaScript Keeps Breaking (and Why Erlang Doesn't)

JavaScript runtimes like Node.js are powerful — but they share one core weakness: when one part of your app crashes, the whole process can go down with it. Fine for small scripts; catastrophic when you're handling thousands of simultaneous users.

Erlang solved this problem in the 1980s using something called a supervision tree (a hierarchy of processes where a parent "supervisor" monitors its children and automatically restarts any that fail). The BEAM VM runs these processes in complete isolation — a crash in one process doesn't touch the others. It's why Ericsson used Erlang in telephone switches that literally cannot afford downtime, and why WhatsApp served 900 million users with only 50 engineers.

The catch? Erlang has a steep learning curve and a much smaller developer community compared to JavaScript's estimated 17 million+ active developers worldwide.

What QuickBEAM Does: JavaScript as Erlang GenServers

QuickBEAM runs JavaScript as GenServers (Erlang's name for individual concurrent processes that hold state and respond to messages) directly inside the BEAM VM. Your JavaScript functions get wrapped in Erlang's supervision system automatically — no manual restart logic, no custom crash handlers required.

Here's what that unlocks in practice:

• Supervised execution: If your JavaScript crashes, Erlang's supervisor restarts it automatically — just like Erlang code that's been running in production for 40 years.
• Actor-model messaging: JS can send and receive messages using Erlang's actor model (a concurrency system where processes communicate only through messages, never through shared memory — eliminating entire classes of race condition bugs).
• Direct Elixir calls: JavaScript can call Elixir functions directly, without any network overhead or serialization delays.
• OTP access: JS code can tap into OTP (Open Telecom Platform — Erlang's 40-year-old standard library for distributed, fault-tolerant systems) for database queries, caching, and distributed coordination.
• Native DOM support: A built-in DOM implementation (the tree structure browsers use to represent web pages) is included, making server-side rendering straightforward.
• TypeScript toolchain: A TypeScript compiler (a tool that adds strict type-checking to JavaScript, catching bugs before they hit production) is bundled — zero extra configuration needed.

In the team's own words: "Run JavaScript as supervised Erlang/OTP processes." That one sentence hides four decades of reliability engineering.

How QuickBEAM Bridges JavaScript and Erlang Backends

Teams building modern backends often end up maintaining two separate systems: a JavaScript layer (for frontend rendering, API logic, or tooling) and an Erlang/Elixir layer (for reliability-critical infrastructure). Bridging them typically means HTTP calls or message queues (software systems that let services communicate asynchronously, like a shared post box between processes).

QuickBEAM collapses that gap. Instead of a JavaScript process and an Erlang process talking over the network, your JavaScript is an Erlang process. The latency between them drops to zero. Data sharing that used to require serialization (converting data into a portable format for transmission across a network) becomes a direct function call.

This is especially valuable for teams running Elixir/Phoenix applications who want to write parts of their backend in JavaScript — without giving up the fault tolerance that drew them to Elixir in the first place.

The Honest Limitations

QuickBEAM earned 83 points and 11 comments on Hacker News roughly 9 hours after launch — solid early traction, but this is a very early-stage project. A few things to keep in mind before depending on it:

• Documentation is sparse: Installation steps aren't fully documented yet. Expect to read source code to get started.
• Dual expertise required: Getting real value from QuickBEAM means understanding both JavaScript's event loop model and Erlang's actor model — two very different concurrency paradigms (mental models for handling many tasks simultaneously).
• Community is still forming: With 11 initial comments, production feedback is essentially zero. Edge cases and real-world failure modes are unknown.
• API surface will evolve: The boundary between JavaScript and Erlang is a genuinely hard design problem. Expect breaking changes before it stabilizes.

The Bigger Picture — JavaScript's Reliability Problem Gets Serious

JavaScript already runs in browsers, on servers (Node.js), at the network edge (Cloudflare Workers), and inside databases (MongoDB). Adding "inside Erlang's 99.9999999%-uptime VM" to that list is a logical next step as teams demand both JavaScript's ecosystem breadth and infrastructure-grade reliability — especially as AI workloads require long-running, always-on process management that Node.js simply wasn't built for.

The closest analogy: it's like hiring from JavaScript's enormous 17-million-developer talent pool while getting Erlang's engineering guarantees. If QuickBEAM matures into a production-ready tool, it could genuinely change how polyglot teams (teams working across multiple programming languages simultaneously) architect their backends.

You can explore the project right now at github.com/elixir-volt/quickbeam. If you're curious about building reliable automation systems, check out our getting started guide for practical tools worth your time today.

Related Content — Get Started | Guides | More News