Timeline

Lines of influence

26 moments across the five BEAM languages, oldest to newest. Filter by language, or follow the threads of influence below.

1986 · Erlang - Erlang is born at the Ericsson Computer Science Lab
**Erlang** was created in **1986** by **Joe Armstrong**, **Robert Virding**, and **Mike Williams** at the Ericsson Computer Science Laboratory in Stockholm. The goal was to find a better way to program telephone exchanges, where the core requirement was massive concurrency and effectively *zero downtime*. The earliest prototypes were written in **Prolog**, whose syntax and pattern matching deeply shaped the new language.1989 · Erlang - JAM: the first real Erlang virtual machine
In **1989** the first Erlang VM, **JAM** (*Joe's Abstract Machine*), was implemented to escape the slowness of the Prolog-based interpreter. Mike Williams wrote the C runtime, Joe Armstrong wrote the compiler, and Robert Virding wrote the libraries. JAM proved roughly **70x faster** than the earlier Prolog interpreter, making Erlang practical for real telecom workloads.1996 · Erlang - The BEAM virtual machine ships in R1B
The **BEAM** VM - originally *Bogdan's Erlang Abstract Machine*, named for **Bogumil "Bogdan" Hausman**, and later maintained by **Björn Gustavsson** - was introduced in Erlang/OTP release **R1B (1996)**. BEAM replaced JAM with efficient threaded-code execution and became the foundation that the entire family of "BEAM languages" now targets.1996 · Erlang - OTP (Open Telecom Platform) delivered
First prototyped under the name *Open System*, the **Open Telecom Platform (OTP)** was delivered in **May 1996**. OTP bundles battle-tested libraries, middleware, and design principles - supervision trees, generic servers (`gen_server`), and the **Mnesia** distributed database - that codify how to build robust, fault-tolerant, concurrent systems. "Erlang/OTP" remains the canonical distribution to this day.1998 · Erlang - AXD301 ATM switch announced
In **March 1998** Ericsson announced the **AXD301** ATM switch, written largely in Erlang and eventually containing well over a million lines of Erlang code. The AXD301 famously achieved nine-nines (**99.9999999%**) reliability and became the canonical proof that Erlang's "let it crash" philosophy could deliver carrier-grade availability.1998 · Erlang - Erlang is open-sourced
After Ericsson Radio Systems banned in-house use of Erlang for new products in February 1998, the language took a different path: on **8 December 1998** *Open-Source Erlang* was announced to the world. Much of the original team soon left to found **Bluetail AB**, and Erlang began its life as a public, community-driven language.2003 · Erlang - Joe Armstrong's PhD thesis on reliable systems
In **2003** Joe Armstrong defended his PhD at the Royal Institute of Technology (KTH) in Stockholm. The thesis, *"Making reliable distributed systems in the presence of software errors,"* distilled Erlang's design philosophy - lightweight processes, isolation, supervision, and "let it crash" - into a foundational text still widely read today.2006 · Erlang - Native SMP multicore support
With Erlang/OTP R11B in **2006**, the runtime gained native **symmetric multiprocessing (SMP)** support, letting the scheduler spread its millions of lightweight processes across multiple CPU cores automatically. This arrived just as multicore hardware went mainstream, giving Erlang programs near-linear scaling without code changes.2008 · LFE - LFE: Lisp Flavoured Erlang announced
**Robert Virding** - co-creator of Erlang - announced the first release of **LFE (Lisp Flavoured Erlang)** on the *erlang-questions* mailing list in **March 2008** (with experiments dating to 2007). LFE is a Lisp-2 dialect built on Core Erlang that compiles to BEAM, fusing **Lisp** macros and homoiconicity with full Erlang/OTP interoperability. The early release was minimal - no shell, no `try`, no recursive `letrec`.2011 · Elixir - First commit to Elixir
**Elixir** began as a research project by **José Valim** at Plataformatec, with the first commit landing on **9 January 2011**. Frustrated by concurrency and tooling limits in Ruby, Valim set out to bring Ruby-like productivity and extensibility (macros, polymorphism) to the Erlang VM while staying fully interoperable with Erlang/OTP.2012 · Luerl - Luerl: Lua on the BEAM
**Luerl**, an implementation of **Lua** written in Erlang/OTP, was started by **Robert Virding** - its public repository was created on **11 February 2012**. After building a Prolog and a Lisp (LFE) on Erlang, Virding wanted to bring an imperative, object-oriented language to the BEAM, and chose Lua. Luerl runs Lua as an embeddable library, letting host programs call Lua and Lua call Erlang.2012 · Elixir - Elixir v0.5.0: first public release
On **25 May 2012**, Elixir reached its first numbered public release, **v0.5.0**. By this point the language had taken on the shape we recognize today: a pipe operator, polymorphism via protocols, a powerful macro system, and the `mix` build tooling that would become central to the ecosystem's developer experience.2014 · Elixir - Phoenix web framework announced
**Phoenix**, started by **Chris McCord** in late 2013 and publicly announced on **4 February 2014**, brought a high-productivity, Rails-inspired web framework to Elixir. Its standout features - **Channels** for real-time WebSocket communication and later **LiveView** - showcased the BEAM's concurrency for building scalable, low-latency web applications.2014 · Erlang - Facebook acquires WhatsApp, built on Erlang
In **February 2014**, Facebook acquired **WhatsApp** for ~$19 billion. WhatsApp ran on Erlang, famously serving hundreds of millions of users - around **450 million** at acquisition - with roughly **2 million concurrent connections per server** and a tiny engineering team. It became the most visible commercial proof of Erlang's concurrency and reliability outside telecom.2014 · Elixir - Elixir v1.0 released
On **18 September 2014**, **Elixir v1.0** shipped - representing over 8,000 commits from 189 contributors since the first commit in 2011. The 1.0 milestone introduced semantic versioning guarantees, signaling stability and triggering rapid growth in the Elixir community, libraries, and production adoption.2015 · Elixir - Phoenix 1.0 released
After about 18 months, 2,500 commits, and 30 pre-releases, **Phoenix 1.0** was released on **28 August 2015**. The stable framework cemented Elixir as a serious choice for production web development, pairing Erlang/OTP's fault tolerance with a polished MVC experience and real-time Channels.2016 · Gleam - Gleam first prototyped
**Gleam** was first created in **2016** by **Louis Pilfold**, initially as the subject of a conference talk before being redesigned into its modern form. Gleam aimed to bring a sound, **ML/Rust/Elm-inspired static type system** to the BEAM - something Erlang and Elixir lacked - while keeping a tiny, friendly language surface.2019 · Gleam - Gleam's first numbered release
On **15 April 2019**, Gleam published its first numbered release. The early compiler - written in **Rust** - produced Erlang source code, giving Gleam programs full access to Erlang/OTP and the wider BEAM ecosystem while adding compile-time type safety.2021 · Elixir - Numerical Elixir (Nx) launches
In **2021** the **Numerical Elixir (Nx)** initiative launched, led by José Valim and collaborators. Nx brought tensors, GPU/TPU compilation (via the EXLA backend), neural networks (Axon), and data processing to the ecosystem - a deliberate push to make Elixir a credible platform for machine learning and data science.2021 · Luerl - Luerl 1.0 released
**Luerl 1.0** was tagged on **28 June 2021**, marking a stable milestone for the Lua-on-BEAM implementation after nearly a decade of development. Luerl targets Lua 5.x and is used as an embeddable, sandboxable scripting layer inside Erlang and Elixir applications.2021 · Gleam - Gleam v0.16 compiles to JavaScript
With **v0.16** in **mid-2021**, Gleam gained a second compilation target: **JavaScript**, alongside Erlang. This let teams share type-safe Gleam code between a BEAM backend and a browser frontend, broadening the language well beyond its original BEAM-only scope.2024 · Gleam - Gleam 1.0 released
On **4 March 2024**, **Gleam 1.0.0** arrived as the language's first stable release, with backwards-compatibility guarantees for the language and `gleam` build tool. Featuring a complete, sound type system, a type-safe OTP actor library, and dual Erlang/JavaScript targets, Gleam quickly became one of the most admired newcomers in developer surveys.2024 · Elixir - Phoenix LiveView 1.0 released
**Phoenix LiveView 1.0** shipped on **3 December 2024**, six years after its first commit. LiveView lets developers build rich, real-time, server-rendered interactive UIs with little or no custom JavaScript - leaning on the BEAM's per-connection processes to push diffs over WebSockets. It became one of Elixir's signature productivity features.2025 · Gleam - Gleam ranks among most admired languages
In **2025**, Gleam appeared in the Stack Overflow Developer Survey for the first time, ranking as one of the most *admired* languages, and was placed in the *Assess* ring of ThoughtWorks' Technology Radar (April 2025). For a language barely a year past 1.0, this signaled unusually strong developer enthusiasm.2026 · Elixir - Elixir v1.20 released
Elixir continued its steady cadence with **v1.20**, released on **3 June 2026**. Recent releases have advanced set-theoretic type inference - a multi-year effort to bring gradual static typing to Elixir without sacrificing its dynamic, metaprogramming-friendly character.2026 · Erlang - Erlang/OTP 29 released
**Erlang/OTP 29** (stable point release 29.0.2 on **10 June 2026**) continued the platform's modern evolution. Four decades on from 1986, Erlang/OTP still anchors the BEAM ecosystem, providing the runtime, scheduler, and OTP libraries that Elixir, Gleam, LFE, and Luerl all build upon.

Influence

prolog syntax, pattern matching & unification Erlangsmalltalk message-passing & live system feel Erlanglisp functional roots & dynamic evaluation ErlangErlang BEAM runtime, OTP & actor model Elixirruby ergonomics, syntax & developer happiness Elixirlisp homoiconic macros & metaprogramming Elixirruby Rails-influenced Phoenix conventions ElixirErlang Core Erlang target & OTP interop LFElisp s-expressions, macros & Lisp semantics LFEErlang host runtime & implementation language Luerllua language semantics being implemented LuerlErlang BEAM target, OTP & concurrency Gleamml Hindley-Milner static type system Gleamrust tooling, syntax & compiler implementation Gleamelm friendly errors & pure functional style GleamElixir ecosystem, Hex packages & community Gleam