Elixir 1.20 Ships as a Gradually Typed Language, Capping a Type-System Effort Begun in 2022
The June 3 stable release completes Elixir's first type-system milestone: the compiler now infers and gradually type-checks every program for verified bugs without requiring any annotations.
Overview
The Elixir core team has shipped Elixir 1.20.0, the stable release that the project frames as the moment the language becomes, in its own words, “now a gradually typed language.” According to the official release announcement, the version landed on June 3, 2026; the changelog records it as v1.20.0 (2026-06-03) and the GitHub release tag shows it published the same day.
The release converts what was previously a string of release candidates into a finished build. The Machine Herald previously reported on the fourth release candidate, which had targeted a May final; the stable version arrived in early June.
What Shipping Means
The central claim of 1.20 is that the compiler can now reason about an entire program. As the release announcement puts it, Elixir will “perform type inference and gradually type check every Elixir program, without introducing type annotations.” In practice that means the compiler surfaces dead code and what the team calls verified bugs — “typing violations that are guaranteed to fail at runtime if executed,” per the same announcement.
The GitHub release notes group the type-system work under headings including “Type inference of guards,” “Whole-body type inference,” “Typing across clauses,” and “Typing of atom and domain keys in maps” — reflecting that inference now extends from individual guards through whole function bodies and across the clauses of a function.
The effort is not new to this release. The announcement opens by noting that “In 2022, we announced the effort to add set-theoretic types to Elixir.” Version 1.20 is positioned as the conclusion of the program’s first stage rather than its endpoint; the January roadmap post had already stated the team would “officially conclude the first milestone as part of Elixir v1.20 and start working on the subsequent ones.”
How the Type System Works
Elixir’s design aims for a type system the project describes as sound, gradual, and developer friendly. The release announcement defines sound as a system where “the types inferred and assigned by the type system align with the behaviour of the program,” and developer friendly as one where “the types are described, implemented, and composed using basic set operations.”
Those set operations are the foundation of the approach. The gradual set-theoretic types reference states that “the types are described, implemented, and composed using basic set operations: unions, intersections, and negation (hence it is a set-theoretic type system).”
The gradual half of the system rests on a dynamic() type. The reference documentation explains that “by intersecting a type with dynamic(), we make the type gradual and therefore only a subset of the type needs to be valid” — the mechanism that lets the compiler check code incrementally without forcing developers to annotate everything up front.
Compatibility and Library Additions
Alongside the type work, 1.20 carries the usual platform and standard-library changes. The changelog states that “This release requires Erlang/OTP 27+ and is compatible with Erlang/OTP 29,” a line corroborated on the GitHub release page.
The changelog also adds new standard-library helpers, among them Integer.popcount/1, Integer.ceil_div/2, List.first!/1, List.last!/1, IO.iodata_empty?/1, Process.get_label/1, and Regex.import/1. On performance, the changelog notes the release “improves compilation times once more, especially on applications with many cores,” and the announcement claims that “our synthetic benchmarks now place Elixir’s build tool as the fastest among them” relative to other BEAM languages.
What Comes Next
The team has been explicit that type signatures — a user-facing way to write down types — are still ahead. The January roadmap post lays out the next steps as the “Introduction of typed structs, allowing struct types to propagate throughout the system,” followed by the “Introduction of type signatures, including for parametric and protocol polymorphism.” The same post maps that work onto “the future Elixir v1.21 (Nov/2026) and v1.22 (May/2027) releases” and cautions that “we will likely continue to see gradual improvements on every release for the next 15 months.”
What We Don’t Know
Whether whole-program inference proves practical across the wider ecosystem will only become clear as libraries and applications upgrade. The release announcement frames the goal as finding verified bugs without developer overhead, but how many real-world codebases surface new warnings under the stricter inference — and how the eventual typed-struct and type-signature APIs are received — are open questions the roadmap leaves for the 1.21 and 1.22 cycles. The author credited on the announcement is José Valim, who has led the type-system program since its 2022 start.