Articles
Comparative essays
Deep dives on how these languages relate, differ, and borrow from one another.
One VM, Many Languages: the BEAM story
How a virtual machine built for telephone switches became a shared home for five very different languages - and what each one inherits the moment it targets it.
The Actor Model: processes and message passing
How the BEAM turns the Actor Model into a runtime: millions of share-nothing processes that spawn, send, and selectively receive.
OTP, Supervision, and "Let It Crash"
How the BEAM turns failure into a feature: gen_servers, supervision trees, restart strategies, and the links and monitors that hold it all together.
From Erlang to Elixir: the lineage
How Elixir inherits Erlang/OTP wholesale, then layers macros, the pipe, and modern tooling on top - and why the two interoperate with zero overhead.
Gleam: static types come to the BEAM
How Gleam adds a sound, fully-inferred type system to the Erlang VM - with no null, no exceptions, and one language that compiles to both Erlang and JavaScript.
LFE: a Lisp on the BEAM
How Erlang co-creator Robert Virding gave the BEAM a real Lisp - S-expressions, homoiconic code-as-data, true compile-time macros, and zero-penalty OTP interop because it compiles straight to Core Erlang.
Luerl: Lua on the BEAM
Not a new language on the VM, but an old one brought into it: a complete Lua 5.x interpreter written in pure Erlang, designed from the start to embed and sandbox untrusted scripts inside Erlang and Elixir apps.
The Virding Thread: Erlang, LFE, and Luerl
One designer, three BEAM languages: how Robert Virding went from co-creating Erlang to building a Lisp on the VM (LFE) and then smuggling Lua into it (Luerl) - and what each move reveals about the runtime underneath.
Hot Code Loading: upgrading a running system
How the BEAM swaps a module's code underneath running processes without dropping a single call - the two-version rule, code:load_file, code_change, and the release machinery telephone switches demanded.
Immutability and Per-Process Memory
Why the BEAM gives every process its own heap, copies messages between them, and can collect garbage without ever stopping the world.
Pattern Matching Everywhere
Function heads, case, receive, and binaries - how four BEAM languages turn pattern matching into the main control-flow tool, why Lua on the BEAM doesn't, and where Gleam's exhaustiveness checker changes the game.
BEAM Processes vs Threads and async
Why a BEAM process beats OS threads, green threads, and async/await: preemptive scheduling, per-process heaps, and millions of cheap actors with no function coloring.
Distribution: clustering the BEAM
How the BEAM stretches its actor model across machines: named nodes, transparent message passing, global and pg for cluster-wide naming, and the trade-offs of a fully-meshed, trust-everything network.
Metaprogramming: macros on the BEAM
How Elixir's quote/unquote turns code into AST tuples you can rewrite, how LFE gets the real Lisp deal with code-as-data macros, and why Gleam deliberately refuses to play the game at all.
Dynamic vs Static Typing on the BEAM
The BEAM was born dynamically typed - so how do Erlang's Dialyzer, Elixir's new gradual set-theoretic types, and Gleam's sound static system each catch type errors, and what does each one promise (or refuse to promise)?