A History of Programming Languages, 2010–September 2026

The Modern Era: Systems Renaissance, Type-System Maturity, Verification, and the AI Turn

Scope. This report covers roughly sixteen years of programming-language design, implementation, and ecosystem evolution — from the emergence of Go and Rust in 2009–2015 through the effect systems and capability revival of the late 2010s and early 2020s, and into the 2023–2026 AI era in which grammar-constrained decoding, verification tooling, and content-addressed code have all pushed into the mainstream. It is written for a language designer building for the AI era, so it deliberately weaves together design philosophy, implementation engineering, and ecosystem/adoption dynamics with equal weight. Where a claim cannot be verified from a fetched primary or high-quality secondary source it is marked “n.a.”


Table of Contents

  1. Framing: what changed in 2010–2026
  2. ERA 7 (the 2010s): the systems renaissance and type-system maturity
    • Go, Rust, Swift, Kotlin, Elixir, Julia, TypeScript, Dart, Elm, PureScript/CoffeeScript/LiveScript, Crystal, Pony, Idris 2, Agda, Lean, Coq → Rocq, Racket, Reason/ReScript, Ceylon, Vala/Genie
  3. ERA 8 (late 2010s–early 2020s): verification, effects, capabilities, and the systems revival
    • Zig, Koka, Eff/Frank, OCaml 5, Unison, Roc, Grain, Gleam, Austral, Vale, Hylo, Carbon, Cppfront, Odin, Jai, Beef, Mojo, HVM (Bend/Vine/Kind), Lamdera, Effekt, Ante
  4. ERA 9 (the AI era, 2023–2026): grammar-constrained decoding, verification renaissance, effect systems in production, capability revival, content-addressing, and WebAssembly maturation
  5. Cross-cutting themes: memory models, effect systems, compiler infrastructure, WebAssembly, package managers, dependency resolution, LSP/tree-sitter, governance
  6. Open questions for the AI-era language designer
  7. Detailed timelines and comparison tables (release timeline, memory-model / package-manager / effect-system / tooling matrices, production-adoption context, canonical writings)
  8. Case studies: five design decisions that shaped the era (Cargo, MVS, borrow checker, TypeScript’s type system, MCP)
  9. Reflections and meta-themes

1. Framing: What Changed in 2010–2026

The dominant story of the 2010s in programming languages was not the arrival of any single language but the collapse of a set of false trade-offs that had governed language design since the 1990s. It became normal to expect: memory safety without a garbage collector (Rust 1.0 announcement, 2015); type systems that inferred almost everything but still carried strong guarantees (Julia paper, 2014); statically typed variants of dynamic languages (TypeScript overview); modern package managers that came bundled with the language and drew from a single, canonical registry (Cargo announcement, 2014); and language-server-driven editor tooling that reached parity across editors within a year or two of a language’s launch (LSP specification).

By the early 2020s a second reorganization was under way. Effect systems — long a research topic under names such as monads, algebraic effects, or “abilities” — moved into shipping languages: OCaml 5’s effect handlers (OCaml 5.0 announcement, December 2022), Unison’s abilities (Unison “the big idea”), Koka’s evidence-passing effect implementation (Koka book). Capability-based security, a strand of research going back to E and Joe-E in the early 2000s, resurfaced under new names in Austral, Monte, and the Object-Capability lineage (Austral capabilities). Content-addressed code was pioneered by Unison (Chiusano, “The big idea”) and echoed by Nix’s derivation model (Nix documentation).

The third reorganization — the AI turn — began in earnest around 2022–2023 when GitHub Copilot and its successors made large-language-model code generation into a routine part of professional development (The New Stack on Copilot’s evolution, 2024). By 2024–2026, language and compiler communities were adapting to a new principal user: an LLM that generates code the human then reviews. Grammar-constrained decoding libraries (PICARD, Outlines, XGrammar, Guidance, SynCode) made it possible for LLMs to emit syntactically valid programs (PICARD, EMNLP 2021; Outlines documentation, 2024). Model Context Protocol (Anthropic, November 2024) began to standardize the way LLMs discover and invoke tools (Anthropic announcement). And a new class of failure — package hallucination or “slopsquatting” — created ecosystem-security incentives to design languages whose module and dependency systems could be validated at edit time (CSA slopsquatting report, 2025).

Together these three shifts — safe systems programming, effects/capabilities/verification going mainstream, and the AI-native language question — define the modern era’s language-design landscape.


2. ERA 7 — The 2010s: Systems Renaissance and Type System Maturity

2.1 Go (Griesemer, Pike, Thompson; Google; sketched 2007, public 2009, 1.0 in 2012)

Origins and motivation. Robert Griesemer, Rob Pike, and Ken Thompson began sketching Go on September 21, 2007; Ken Thompson started a compiler that generated C in January 2008, Ian Taylor began a GCC front end independently in May 2008, and Russ Cox joined in late 2008. Go was open-sourced on November 10, 2009 and reached version 1.0 in March 2012 (Go FAQ; Wikipedia: Go). The three creators described the initial design as a “thought experiment” asking, “What should a modern, practical programming language look like?” — a feature had to be agreed by all three before it was accepted, which produced a language famous for what it left out (How Go was made — Rob Pike, 2015 talk).

The motivating problem, articulated repeatedly by Pike, was Google’s server-side C++ codebase: long compilation times, complex language, and difficulty making concurrent programs correct (Google Talks: “Why Go?”, how-go-was-made slides). Go’s answer was to strip C++ down to a small orthogonal set of features, add first-class concurrency, and put the compilation-speed problem into the language spec (no header files, no template metaprogramming, mandatory unused-import errors).

Concurrency: goroutines and channels. Go’s concurrency model descends directly from Tony Hoare’s CSP through Rob Pike’s Newsqueak and Alef languages of the 1990s (Golang design: CSP lineage; Pike, “Concurrency is not parallelism”, 2012). Goroutines are lightweight user-space threads scheduled by the Go runtime onto OS threads; channels provide typed synchronous or buffered communication between goroutines. Under the hood the scheduler uses an M:N model with work-stealing across per-P run queues; the channel implementation combines a lock-protected ring buffer with parked-goroutine queues for send and receive (Go channels deep dive).

Design philosophy: deliberate simplicity and gofmt culture. Go’s opinionated tooling has been as influential as the language. gofmt was introduced early to eliminate style bikeshedding by dictating one canonical format (Rob Pike, gofmt talk, 2015); subsequent Go tooling (go vet, go test, go build, later go mod) followed the same principle of a single opinionated command with no configuration (Go tooling summary). The cultural effect — no lint-config wars, uniform code across the ecosystem — has been widely copied (rustfmt, black, prettier, deno fmt, zig fmt).

Modules and Minimum Version Selection. In 2018 Russ Cox introduced Go modules and the Minimum Version Selection (MVS) algorithm, a deliberately simple alternative to SAT-style dependency solvers used by npm and Cargo. MVS picks, for each module, the minimum version that satisfies the union of all go.mod requirements — no backtracking, no lock file needed for correctness, and reproducible builds by construction (Russ Cox, “Minimal Version Selection”). MVS was combined with a global checksum database (sum.golang.org) that pins module hashes across the ecosystem, giving Go supply-chain properties that most package ecosystems still lack in 2026 (Go modules reference).

Cox’s essay on MVS is worth reading as a design document: he argues explicitly that the goal of a dependency system is high-fidelity builds (the same result across time, machines, and users) and that SAT-based resolvers optimize for a different goal (the latest compatible versions of everything) at the cost of correctness surprises and build-time nondeterminism (“Minimal Version Selection” essay, Cox). MVS’s central trick is that when two dependencies require version 1.4 and 1.7 of the same module, MVS picks 1.7 (the minimum that satisfies both), not the latest available 1.9 — so a new release of the module cannot silently change your build. Reproducibility comes from a go.sum file that records cryptographic checksums of every module version the build has ever used, plus the mandatory server-side sum.golang.org transparency log for module hashes.

Garbage collector. Go’s GC has evolved substantially since 1.0: from a stop-the-world mark-sweep to a concurrent tri-color mark-and-sweep with sub-millisecond pauses since Go 1.5 (2015), then to sub-100μs typical pauses with the addition of scavenger and pacer improvements through Go 1.12–1.19 (Various Go runtime blog posts, 2015–2022). The GC is designed to prioritize latency over throughput: Go accepts a somewhat higher CPU overhead in exchange for consistent, small pauses that make Go suitable for latency-critical server workloads.

Compilation model. Go’s compilation speed is a first-class design constraint. The language rejects header files, avoids template-style generics (until 1.18, and even then with careful implementation), and requires all imports to be used (unused imports are a compile error). Package compilation is per-package rather than per-file, and the compiler emits a compact .a archive for each package that later imports can consume without re-parsing sources. The result is that even large Go binaries typically compile from scratch in seconds rather than minutes (Pike, “Public Static Void” and various Go compilation talks).

Generics (Go 1.18, March 2022). Go shipped without generics in 2012 and did not add them until Go 1.18 in March 2022 — nearly a decade of one of the loudest, most-debated omissions in modern language history. Multiple designs were attempted (Type Functions in 2010, Generalized Types in 2011, Contracts in 2018, and finally Type Parameters in 2020) before the community converged on a constraint-based design based on interface types (Golang design: history of Go generics; Go generics past designs, present features). Ian Lance Taylor and Robert Griesemer led the final proposal (“Type Parameters Proposal”); the implementation used monomorphization for small types and GC-shape stenciling for larger ones (Go blog: An Introduction to Generics). The long debate is instructive: the Go team explicitly preferred no generics over the wrong generics, and repeatedly cancelled proposals whose ergonomics or teachability the team did not accept.

Status and lasting influence, 2026. Go is the backbone language for Kubernetes, Docker, Terraform, and much of the CNCF ecosystem, and remains the dominant server-side language at many web companies (Go blog, various; Wikipedia: Go). Notable production Go deployments include Google’s own SRE and infrastructure tooling, Cloudflare (large parts of its edge software), Uber (server infrastructure), Twitch (chat infrastructure), and much of the modern container/cloud tooling stack.

Its most durable design contributions are (1) opinionated tooling as a cultural default, (2) minimum-version selection as a workable simple alternative to SAT-solving package resolvers, (3) checksum databases in the standard toolchain, (4) demonstrating that fast compilation is a feature worth designing the whole language around, and (5) proving that a narrow language can win on the strength of a wide ecosystem and coherent culture.

Open questions. Go’s approach to error handling (explicit if err != nil checks) has been debated for years; multiple community proposals for try/? sugar have been rejected. Go’s interface satisfaction is structural (a type satisfies an interface if it has the right methods, without explicit declaration), which some communities find surprising. Go’s rejection of iterators — until the 1.22–1.23 additions of range-over-func — was a long-standing gap that shows the price of the language’s simplicity orientation.

2.2 Rust (Graydon Hoare and community; Mozilla; 1.0 in May 2015)

Origins. Rust began as Graydon Hoare’s personal project around 2006; the earliest public traces refer to a language then called “Rust” that already emphasized safe concurrency and a distinctive typestate system (Rust Wikipedia article). Mozilla began sponsoring the project in 2009 as part of its work on a new browser engine (which became Servo); Rust was announced publicly in 2010 and iterated aggressively through pre-1.0 releases, with major features (typestate, green threads, an early ~T/@T sigil system, and a runtime) being added and later removed (Rust project lore).

The road to 1.0. Rust 1.0 was released on May 15, 2015. The 1.0 release marked the point at which the ownership-and-borrowing memory model, monomorphic generics, traits, and cargo were declared stable, and Rust committed to backward compatibility going forward (Rust 1.0 announcement, May 2015). The stability promise has held remarkably well: as of the 2024 edition, code that compiled on Rust 1.0 largely still compiles today.

Getting to 1.0 required removing an enormous amount of pre-1.0 machinery: a green-threaded runtime, the typestate system, ~T (unique pointer) and @T (managed pointer) sigils, and initial attempts at implicit type conversion. The pre-1.0 iterations are documented in a striking series of retrospective posts by Graydon Hoare and other early contributors (Community history summaries; Reddit thread on Rust history). The final 1.0 design reflected years of pragmatic pruning: the surviving core is ownership + traits + monomorphized generics + zero-cost abstractions.

Ownership and borrow checking. Rust’s central design contribution is a memory-safety model built on affine types, borrow checking, and lifetimes. Each value has a single owner; references borrow from the owner subject to a rule that either any number of shared (&T) or exactly one mutable (&mut T) reference may exist at a time. Region-based lifetimes ensure references never outlive the values they point to. The design descends from Cyclone (Grossman, Morrisett, et al., 2002) and from earlier work on linear and affine types (Rust borrow checker history, community summary; History of the borrow checker discussion). Non-Lexical Lifetimes (NLL) landed in 2018, moving from lexical scopes to a control-flow-graph analysis; Polonius, a Datalog-based reformulation begun by Niko Matsakis around 2018, has been an ongoing project to make the borrow checker even more flow-sensitive (Rust NLL announcement, 2018).

The formal semantics of ownership are still an active research area. The 2025 arXiv paper Place Capability Graphs: A General-Purpose Model of Rust’s Ownership and Borrowing Guarantees (Grannan, Bílý, Fiala, Geer, de Medeiros, Müller, Summers; UBC and ETH Zurich) proposes PCGs as a directed hypergraph model of the results of Rust type-and-borrow checking, capturing move-based ownership transfer, field-level decomposition via unpack/pack operations, mutable and shared borrows, reborrowing, borrow expiry, nested lifetimes, and capabilities flowing back to lenders (Place Capability Graphs paper, arXiv:2503.21691v3). The paper is representative of a larger effort to give Rust a formal foundation for downstream verification tools such as Prusti, Flowistry, Aeneas, Verus, and Creusot.

Traits, generics, and monomorphization. Rust’s generic system uses monomorphization: a call to Vec::<i32>::push and a call to Vec::<String>::push produce two entirely separate instantiations of the code. This gives zero-cost abstraction (no runtime dispatch, no boxing) but produces large binaries. The design decision — inherited from C++ templates — has been controversial in exchange for its performance profile. Rust also supports dyn Trait for runtime polymorphism when needed. Traits themselves are more principled than Haskell type classes in some ways (associated types, generic associated types added in 2022) but less powerful in others (no higher-kinded types).

Cargo, crates.io, and the RFC process. Cargo was announced in November 2014, several months before Rust 1.0, and shipped with Rust from 1.0 forward — the first mainstream systems language to ship a first-class package manager from day one (Cargo announcement, November 2014; Cargo documentation). Cargo introduced the now-standard convention of a Cargo.toml manifest, a lockfile pinning transitive dependencies, workspace-based multi-crate layouts, feature flags, and per-crate test/example/benchmark conventions. It uses a SemVer-aware resolver (Cargo reference). The design has been directly copied by many later ecosystems (uv, Bun, Deno’s install command).

The RFC process (started before 1.0 and codified in 2014–2015) was another lasting institutional contribution: any nontrivial change to the language or standard library must be proposed as a pull request against the rust-lang/rfcs repository, reviewed publicly, and approved by the relevant team (Rust governance). Python (PEPs) predated it; Swift Evolution, Kotlin KEEPs, TC39 stages, and many other modern proposal systems descend from it.

Editions. Rust ships new language “editions” every three years — 2015, 2018, 2021, and 2024 — which allow breaking syntactic changes (e.g., new keywords, different macro capture semantics) to be introduced per-crate without breaking existing dependencies. Crates in different editions link together, but the compiler applies the crate’s own edition rules when parsing and desugaring (Rust book: editions appendix; Style guide edition changes). The mechanism has been widely admired as a solution to the paradox of language evolution: how to change without breaking.

Rust Foundation (February 2021). In February 2021 Rust transitioned governance from Mozilla to an independent, member-based Rust Foundation. Founding members included Amazon Web Services, Google, Huawei, Microsoft, and Mozilla (Mozilla welcomes the Rust Foundation, February 8, 2021; Rust Foundation launch, blog.rust-lang.org, February 8, 2021). Mozilla had laid off much of its Servo team in August 2020, which forced the community to accelerate the foundation plan (DevClass: Rust turns over new leaf with own foundation, February 9, 2021).

Adoption story. Rust has become the second language (after C) officially permitted in the Linux kernel; Microsoft has been rewriting parts of the Windows kernel in Rust; AWS Firecracker (the microVM behind Lambda and Fargate) is written in Rust; and the Cloudflare, Discord, Dropbox, and Figma engineering teams have publicly documented major Rust production deployments. It has topped the Stack Overflow “most loved language” survey every year since 2016 (Wikipedia: Rust).

The Rust for Linux project was accepted upstream in Linux 6.1 (October 2022). The initial patch series added minimal Rust support (build infrastructure, alloc crate subset, kernel binding scaffolding); subsequent releases added device drivers written in Rust (a NVMe driver, some GPU driver work). By 2025 several drivers were shipping in Rust in mainline Linux. The Rust for Linux debate was famously acrimonious in 2022–2024, culminating in high-profile maintainer resignations over the challenge of maintaining Rust bindings against churning kernel C APIs.

On the tooling side, Rust’s adoption in tooling written in Rust — ripgrep, fd, bat, exa, delta, uv, ruff, dprint, biome, deno, bun, esbuild-like reimplementations — has been transformative for developer productivity across many ecosystems, including ecosystems otherwise unrelated to Rust (Python’s uv and ruff, JavaScript’s biome, dprint, and Node/npm-alternatives).

Lasting influence. Rust demonstrated that (1) memory safety without a GC is achievable in a mainstream language given the right type system; (2) an RFC-driven, foundation-governed language project can outlive its corporate sponsor; (3) editions are a workable answer to language evolution; (4) shipping a first-class package manager and build tool is now table stakes; and (5) high-quality compiler diagnostics change what programmers expect from every language.

The influence has been most visible in derivative languages: Vale, Austral, Hylo, and Carbon all explicitly frame themselves as “what if we changed one axis of Rust’s design.” Cyclone’s 2002 ideas have thus been reincarnated in five distinct modern designs, each exploring a different point in the memory-safety-without-GC design space.

Open questions. Rust’s compile times remain slow (a fundamental cost of monomorphization + LLVM); async Rust’s ergonomics have been contentious since stabilization in 2019 (Pin, poll, executor choice); the language’s complexity has grown steadily and represents a real learning barrier; and the borrow checker remains difficult to teach even after eight years of pedagogical iteration.

2.3 Swift (Chris Lattner and team; Apple; public 2014, open-sourced 2015)

Origins. Chris Lattner — the creator of LLVM — began work on Swift in July 2010 as a personal project, keeping it confidential for over a year before showing it to Apple’s senior leadership in 2011. A larger team gradually joined; Swift was announced at WWDC in June 2014 alongside Swift 1.0 (Wikipedia: Swift; Chris Lattner biography). Apple’s stated motivation was to replace Objective-C as the primary language of the Apple platforms — a language whose Smalltalk-derived message-passing syntax and manual memory-management history had made it a barrier for new developers.

Design. Swift is a high-level, general-purpose, compiled, multi-paradigm language supporting protocol-oriented, object-oriented, functional, imperative, block-structured, declarative, and concurrent programming (Wikipedia: Apple Swift). It uses C-family curly-brace syntax without required semicolons, algebraic-data-type-style enums with associated values, optional types with ? and ! syntax for null-safety, generics with constraint-based bounds, first-class value semantics for structs and enums, and Automatic Reference Counting (ARC) for memory management (compile-time-inserted retain/release calls; no tracing GC).

Protocol-oriented programming. At WWDC 2015 Dave Abrahams delivered the influential “Protocol-Oriented Programming in Swift” talk, arguing that protocols with associated types and default implementations subsume most of what OOP inheritance provides while composing better (InfoQ: Protocol-Oriented Programming in Swift, June 2015; Pluralsight guide). The style — protocols as the primary unit of abstraction, structs as the primary carriers of state — has since informed several later languages (Roc’s abilities, Hylo’s use of value semantics).

Swift Evolution and governance. After open-sourcing Swift in December 2015, Apple established the Swift Evolution process on swift.org: language changes are proposed as pull requests to a public repository, discussed on the swift-evolution mailing list/forum, reviewed by a core team or specialized “steering group,” and either accepted, deferred, or returned for revision (Swift Evolution overview; Swift Contributing guide; Swift Language Steering Group). In 2022 Swift established topic-specific steering groups (Language, Ecosystem, Platform) to decompose the review load.

Concurrency and Swift 6. Swift 5.5 (2021) introduced async/await, Structured Concurrency, and Actors. Swift 6 (2024) added a strict-concurrency mode that turns previously warning-only data-race hazards into compile errors when opted in, using an “isolation” analysis over actors and Sendable types (Swift 6 release notes; n.a. on specific version numbers below the level of the linked pages).

Implementation and platform reach. Swift compiles through LLVM to native code, uses ARC for memory management, and interoperates with Objective-C at the object/class level. Beyond iOS/macOS/tvOS/watchOS/visionOS, Swift runs on Linux and Windows; the community has produced Swift-on-server frameworks (Vapor, Hummingbird), and Apple has begun to use Swift for its own internal server workloads.

Package manager and distributed compilation. Swift Package Manager (SwiftPM), introduced with the open-source release in 2015, ships a manifest-file-based dependency system (Package.swift) that itself is written in Swift and executed by the compiler to describe the package graph. From 2020 forward SwiftPM supports binary dependencies and, in Swift 5.9+, macro packages that run at compile time — an unusual design in which the compiler builds and loads macro plugins from user packages.

Server-side Swift. Apple has invested in server-side Swift with the Vapor and Hummingbird frameworks and with SwiftNIO (the async event-loop library that also powers Apple’s iCloud infrastructure). Swift-on-server has a small but committed user base and is one of the few systems languages with first-class async/await + structured concurrency out of the box.

Lasting influence. Swift is the model for a Big-Tech-sponsored language that transitioned to genuinely open governance: its Evolution process and steering-group structure have been widely imitated (Kotlin KEEPs, TC39). Protocol-oriented programming remains one of Swift’s most-cited design contributions.

Open questions. ARC’s cost — retain/release calls on every reference-count change — has been a persistent performance concern; the Swift team has done substantial work on ARC optimization but the model is fundamentally slower than a tracing GC for allocation-heavy workloads. Swift’s type inference can be slow (the compiler sometimes takes seconds to resolve expressions like large array literals). Swift’s build times have historically been slow; incremental compilation and module distillation have been ongoing engineering priorities.

2.4 Kotlin (JetBrains; 2011; Google Android first-class in 2017)

Origins. JetBrains announced the Kotlin project in July 2011 as a “new statically typed pragmatic language for JVM” targeting IntelliJ’s own use cases; the first “Hello, world!” blog post came from the JetBrains team on July 19, 2011 (Kotlin media kit; Wikipedia: Kotlin). The language was named after Kotlin Island near St. Petersburg. Kotlin 1.0 shipped in February 2016, the same year JetBrains committed to backward compatibility (JetBrains “Hello world” blog, 2011; Kotlin 1.0 release notes).

Design. Kotlin is a pragmatic Java replacement: statically typed, null-safety in the type system (String vs. String?), data classes with auto-generated equality/hashCode, extension functions, smart casts, sealed classes, when-expressions with exhaustiveness checking, and — crucially — 100% Java interoperability at the JVM bytecode level (Kotlin documentation). The design goal was explicitly not novelty but ergonomics: reduce Java boilerplate, remove the most common categories of NullPointerException, and let teams migrate incrementally.

Coroutines. Kotlin added coroutines as a language feature in 1.3 (2018), implemented as a compile-time CPS (continuation-passing style) transformation over suspend-marked functions. The user model is structured concurrency built on CoroutineScope and Job, with Flow for reactive streams (Kotlin coroutines overview; Coroutines basics; Asynchronous programming with coroutines spec). The design — cooperative suspension threaded through a compile-time transformation, no runtime green-thread scheduler required — has been influential.

Google adoption. At Google I/O 2017 Google announced Kotlin as a first-class language for Android development; in 2019 Google went further and declared Android development “Kotlin-first” (Kotlin timeline and Google adoption, JetBrains sources). This effectively made Kotlin the primary application language of mobile Android — one of the fastest large-scale language adoptions in industry history, comparable to Swift’s for iOS.

K2 compiler and Kotlin Multiplatform. JetBrains has spent the 2020s on a new “K2” compiler front-end that rewrote parsing, type-checking, and IR generation to be modular, faster, and better suited to IDE integration. K2 stabilized around Kotlin 2.0 (2024) (JetBrains blog, various Kotlin posts). Kotlin Multiplatform (KMP), which lets shared Kotlin code target JVM, JavaScript, Native (LLVM), and iOS from one source tree, moved to stable during 2023–2024.

Compose Multiplatform and Server. Beyond mobile, Kotlin has been deployed at scale in server infrastructure at companies including Netflix, Uber, JetBrains itself, Amazon (some services), and many European banks. Compose Multiplatform (the JetBrains cross-platform reimplementation of Google’s Jetpack Compose UI framework) reached stable on desktop and iOS during 2024–2025, positioning Kotlin as a legitimate cross-platform UI language competing directly with Flutter/Dart.

Lasting influence. Kotlin proved that a pragmatic Java replacement could win by ergonomics rather than novelty; its compile-time coroutine model shows an alternative to green-thread-runtime approaches (Go, Java Loom); and its extension-function-heavy standard-library idiom has become widely imitated.

Open questions. Kotlin/Native (Kotlin compiled through LLVM to native code without a JVM) has had persistent performance and tooling gaps compared to Kotlin/JVM; the K2 compiler transition took longer than planned and left some IDE features regressing during the transition; and Kotlin’s simultaneous targeting of JVM, JS, native, and Wasm creates a growing surface area of compatibility issues to maintain.

2.5 Elixir (José Valim; 2011; on the BEAM)

Origins. José Valim, a Rails Core contributor, began Elixir in 2011 while looking for a language that could give him Erlang/OTP’s concurrency and fault-tolerance guarantees without Erlang’s syntactic conservatism. Valim has explained that the initial focus was on providing better tooling and metaprogramming on the BEAM VM (Wikipedia: Elixir; EEF interview with José Valim). The first public release, v0.5.0, came in May 2012 (Elixir v0.5.0 released, May 25, 2012).

Design. Elixir is a functional language with Ruby-inspired syntax, immutable data, pattern matching, protocols (Elixir’s version of Rust traits or Haskell type classes), and Lisp-style macros implemented via quote/unquote over an abstract syntax tree. It compiles to BEAM bytecode and inherits Erlang’s actor model (processes, mailboxes, spawn/send/receive), OTP behaviors (GenServer, Supervisor), and hot code reloading.

Phoenix and LiveView. The Phoenix web framework (Chris McCord, 2014) has become the flagship Elixir project. Phoenix LiveView, introduced around 2018–2019, was a genuinely novel contribution: instead of a JavaScript SPA or a full page reload, LiveView renders HTML server-side, opens a WebSocket, and sends minimal DOM diffs on state changes, allowing rich interactive UIs to be built in server-side Elixir with almost no client-side JS (Phoenix LiveView README; LiveView overview). The pattern has influenced React Server Components, Hotwire, Livewire, and Blazor.

Adoption. Elixir has become the dominant modern language on BEAM (largely displacing new Erlang application code). Notable production deployments include Discord’s WebSocket infrastructure (handling billions of concurrent messages), Pinterest’s notification pipeline, Toyota Connected, Change.org’s petition platform, and many financial-services and healthcare startups that need high uptime with small operations teams. Elixir 1.0 shipped in September 2014 and the language has followed a slow, deliberate release cadence since.

Numerical Elixir and AI. From 2021 onward Valim has led a project called Nx (Numerical Elixir) that adds tensor operations, XLA/EXLA integration for JIT compilation to GPU/TPU, and a machine-learning library (Axon) built on top. The combination positions Elixir as a viable ML-serving language on the BEAM — an interesting hedge as the AI era reshapes language economics (Elixir community reports, various 2023–2025).

Lasting influence. Elixir demonstrated (1) that a language could inherit a mature runtime (BEAM) and add a modern surface without compromising the runtime’s guarantees; (2) that Lisp-style macros in a non-Lisp syntax could work at production scale; and (3) that a small language team could take on a much larger runtime and evolve it (adding types, Nx tensors, etc.) collaboratively with the parent Erlang community.

2.6 Julia (Bezanson, Karpinski, Shah, Edelman; MIT; 2009–2012, 1.0 in 2018)

Origins. Julia was started at MIT in 2009 by Jeff Bezanson, Stefan Karpinski, Viral Shah, and Alan Edelman; the first public release came in 2012, and the founders published a widely-cited manifesto (“Why We Created Julia”) describing the goal as solving the two-language problem — the requirement to prototype scientific code in a dynamic language (Python, MATLAB, R) and then rewrite hot paths in a static one (C, Fortran) (Julia paper: A Fast Dynamic Language for Technical Computing, 2012; Julia paper: Julia, a Fresh Approach to Numerical Computing, 2014, arXiv:1411.1607).

Design. Julia’s key design decisions are (1) multiple dispatch as the primary organizing abstraction: methods are selected based on the runtime types of all arguments, rather than the type of a single receiver; (2) parametric types with a rich lattice (invariant, covariant on parameter tuples); (3) an AOT-then-JIT execution model — user code is lowered to a typed intermediate representation and then JIT-compiled through LLVM at first call (Julia paper, ArXiv); (4) a homoiconic macro system inherited from Lisp. Julia 1.0 shipped in August 2018 with a commitment to backward compatibility; Julia has since followed a roughly semi-annual release cadence.

Ecosystem. Julia’s package manager (Pkg) uses a per-project Project.toml/Manifest.toml model with SAT-based dependency resolution and full binary artifact support. Julia has become influential in numerical computing (DifferentialEquations.jl, Flux.jl, JuMP), scientific machine learning (“SciML”), and climate modeling (the Clima project). The AOT-compilation problem — precompiling packages so first-call latency is acceptable — has been a persistent engineering focus; PackageCompiler.jl and sysimages address it partially.

Time-to-first-plot problem. Julia’s most-discussed pragmatic drawback for years was “time to first plot” — the latency between starting Julia and getting a plot on screen, which required JIT-compiling substantial pieces of the plotting stack. Julia 1.9 (May 2023) introduced package images (“pkgimages”) that persist native-compiled code across sessions, cutting first-plot latency by an order of magnitude. Julia 1.11 and 1.12 (2024–2025) continued this work.

SciML and scientific computing. The SciML organization (Chris Rackauckas et al.) has built the DifferentialEquations.jl, ModelingToolkit.jl, and Symbolics.jl ecosystem — arguably the most sophisticated numerical-DE stack in any language. Julia is also used in production at the Climate Modeling Alliance (CliMA) for climate simulations, at Pumas AI for pharmacometric modeling, and by the FAA for aircraft-simulation verification.

Lasting influence. Julia proved that multiple dispatch with parametric types could scale to a full numerical stack, and that a language that shares an LLVM backend with a static language can produce code within a small factor of C/Fortran on numerical kernels.

Open questions. Julia’s compilation latency, though hugely improved, remains higher than Python’s; static analysis of Julia’s dynamic dispatch is inherently hard, which limits IDE tooling and warning quality; the ecosystem is smaller than Python’s for general-purpose data science even though it beats Python on numerical performance.

2.7 TypeScript (Anders Hejlsberg and team; Microsoft; announced October 2012)

Origins. Microsoft announced TypeScript on October 1, 2012, with Anders Hejlsberg — creator of Turbo Pascal, Delphi, and C# — as chief architect (Wikipedia: TypeScript; Anders Hejlsberg biography). The motivating problem was Microsoft’s own internal large-scale JavaScript codebases (Office Online, VS Code); the design goal was a strict superset of JavaScript with an optional, erasable type system that could catch bugs at compile time without changing runtime semantics.

Design. TypeScript’s most distinctive design choices are (1) structural typing: two types are compatible if they have compatible members, not because they share a name or nominal declaration; (2) gradual typing via the any type (and later unknown), letting large codebases migrate incrementally; (3) type erasure — TypeScript compiles to JavaScript by stripping type annotations, so the runtime cost of the type system is zero; (4) a very expressive type system including conditional types (T extends U ? A : B), mapped types ({ [K in keyof T]: F<T[K]> }), template-literal types, and inference in higher-kinded positions (TypeScript handbook: TypeScript for JS programmers; ACM: Static Typing for Ruby on Rails / structural typing papers).

DefinitelyTyped and the ecosystem. From very early, TypeScript relied on a community-maintained repository of type definitions for existing JavaScript packages: DefinitelyTyped. By 2024 an increasing majority of major npm packages ship types directly rather than through DefinitelyTyped, but the model of “types for packages that never wrote types” was crucial to bootstrapping the ecosystem (The New Stack: TypeScript getting popular; Packages ship TypeScript types vs. DefinitelyTyped, PkgPulse).

Adoption arc. TypeScript’s growth from a Microsoft internal tool to the default professional JavaScript dialect is one of the most successful language adoption stories of the era. VS Code (2015) both used TypeScript and integrated it as a first-class editor language, creating a flywheel; Angular 2 (2016) adopted TypeScript as its primary language; Deno (2018) chose TypeScript as its native scripting language; and by 2024 the majority of new open-source JavaScript projects on GitHub start in TypeScript (Softronic: TypeScript in 2026 the professional default).

Editor tooling. VS Code (Microsoft, 2015) uses the TypeScript compiler as both a linter and a language server; every TypeScript project gets rich IntelliSense out of the box, and the resulting “types-in-your-editor-immediately” experience became the industry standard against which every subsequent language was measured. When Microsoft released the Language Server Protocol in 2016, TypeScript’s language service was one of the first implementations.

Native compiler rewrite (2025). In March 2025 Anders Hejlsberg announced that the TypeScript team was working on a native port of the TypeScript compiler — a rewrite in Go (chosen for its garbage collector, memory model, and portable native compilation) that would run 10× faster than the current TypeScript-on-Node compiler (TypeScript native port announcement, March 2025, Microsoft DevBlogs; n.a. on precise release timeline). The port is the largest engineering change to TypeScript since its initial release and reflects the practical performance pressures of massive TypeScript codebases (Microsoft’s own VS Code, Bloomberg’s terminal, and Meta’s WhatsApp Web all run into TypeScript compile-latency limits).

Lasting influence. TypeScript is the definitive success story for gradual typing over an existing dynamic language. Its type system has become richer than most academic type systems shipping in production (conditional/mapped/template-literal types); its structural-typing pragma has been imitated in Sorbet (Ruby), Hack (PHP), and Python’s PEP 544 (Protocols). Its adoption arc has become the reference for “how a Big Tech company can ship a language.”

Open questions. TypeScript’s type system is Turing-complete (via conditional and mapped types), which produces both extraordinary expressiveness and pathological compile-time performance in some cases. TypeScript’s willingness to unsound gaps (variance defaults, any propagation, class-field ordering issues) has kept the barrier to adoption low but occasionally frustrates library authors. The Deno/Bun runtimes’ native TypeScript execution has raised the question of whether TypeScript should become a runtime language on Node, not just a compile-time one — a debate reopened by the Node core team’s --experimental-strip-types feature in Node 22 (2024).

2.8 Dart and Flutter (Google; 2011; Flutter era 2018+)

Origins. Google announced Dart in October 2011 with an initial design by Lars Bak and Kasper Lund, who had previously built the V8 JavaScript engine at Google. Dart was announced with an ambition to replace JavaScript in the browser via a native Dart VM that would ship in Chrome; that VM plan was abandoned in 2015 (Wikipedia: Dart). The language stagnated until Google repositioned it as the language of Flutter (2018).

Design. Dart is a class-based, single-inheritance, statically-typed language with sound null safety (added in Dart 2.12, 2021), mixins, isolates (share-nothing lightweight processes for concurrency), and both JIT (for hot-reload during development) and AOT (for release builds) compilation. Dart uses PubGrub as its dependency resolution algorithm — a novel SAT-adjacent algorithm developed by Natalie Weizenbaum at Google that produces small, human-readable failure explanations when constraints are unsatisfiable (PubGrub explainer). PubGrub was later adopted by Poetry, Rye, and uv on the Python side.

Flutter era. Flutter (May 2017 beta, Dec 2018 1.0) is a cross-platform UI framework whose renderer draws every widget directly onto a canvas (originally Skia, later Impeller) rather than delegating to native OS widgets. Flutter compiles Dart to native ARM/x86 on iOS/Android and to JavaScript or WebAssembly on the web. Flutter’s success (adopted by BMW, Alibaba, Toyota, ByteDance, and much of Google’s own consumer apps) made Dart into a widely-used production language for the first time.

Dart 3 records and patterns (2023). Dart 3 (May 2023) added records, pattern matching, sealed classes, and switch expressions — features imported from ML-family functional languages. The additions made Dart significantly more expressive, and continued its slow evolution from a Java-adjacent OOP language into a hybrid OOP/FP language similar in feel to Kotlin or modern Scala.

Lasting influence. Dart’s greatest impact has been Flutter’s success in cross-platform mobile development and PubGrub’s success as a dependency-resolution algorithm; the language itself is a competent modern OOP design without a distinctive theoretical contribution.

2.9 Elm, PureScript, CoffeeScript, LiveScript, and the JS-transpiler moment

Elm. Evan Czaplicki designed Elm as his 2012 senior thesis at Harvard; the language is a pure functional, statically-typed ML-family language that compiles to JavaScript, designed for building web front-ends. Elm’s most influential contribution was The Elm Architecture — Model/Update/View with unidirectional data flow and immutable state — which directly inspired Redux, ngrx, Elmish, and many other state management libraries (Elm site; Elm news). Elm’s design decisions included pure functions everywhere, algebraic data types for exhaustive pattern matching, and a promise of “no runtime exceptions.” Compiler error messages became a signature — cited by many later languages including Rust as an inspiration for the modern style of diagnostics.

Elm’s community stagnated after 2019 as Czaplicki chose extremely slow, opinionated releases; the language is widely admired but not widely adopted in 2026. Elm 0.19 (August 2018) removed the ability for user code to publish packages with FFI (“kernel code”) except for the core team, a decision that drove much of the community either away or into hard forks (Elm-Explorations, Lamdera). The Lamdera project (see §3.15) has continued to maintain a distribution of Elm with a stable release cadence.

Elm’s design contributions — The Elm Architecture, first-class friendly compiler errors, ports for FFI, and a truly pure functional core — are widely regarded as classic even by developers who no longer use Elm. Every modern JavaScript state-management library owes something to TEA. Elm’s compiler error style directly influenced Rust’s diagnostic revolution around 2016.

PureScript. PureScript (Phil Freeman, 2013) is a strict, purely functional language with a Haskell-inspired type system (including row polymorphism and type classes) that compiles to JavaScript. It is the technical successor to attempts like Haste and Fay for compiling Haskell-like languages to JS (PureScript documentation and JS-transpiler history summaries).

CoffeeScript and LiveScript. CoffeeScript (Jeremy Ashkenas, 2009) was the first widely-adopted “better syntax for JavaScript” transpiler; its Python/Ruby-inspired indentation-based syntax and comprehensions were absorbed into JavaScript itself through ES6’s arrow functions, classes, destructuring, and default arguments. LiveScript (Jeremy Ashkenas / gkz, 2011) added a more Haskell-inspired feature set on top of CoffeeScript’s foundations. Both languages have declined sharply in the 2020s; TypeScript filled the design niche they had opened.

2.10 Crystal (Manas / community; 2014)

Crystal is a Ruby-inspired, statically-typed, natively-compiled language. Its central design decision is global type inference — programs are usually written without any type annotations and the compiler infers a set of concrete types for every expression through whole-program analysis (Crystal official site and blog). Crystal reached 1.0 in March 2021. The language has found a small but committed production community (Kemal web framework, Amber, Lucky); its concurrency model uses fibers scheduled onto OS threads.

Crystal’s global type inference is unusual in a production-shipping language: it produces succinct code with Ruby-like ergonomics but very Rust-like performance, at the cost of long compile times for large codebases (the whole-program analysis does not incrementalize well). Crystal 1.0 also introduced parallelism experimental support (multi-thread execution of fibers across OS threads) after years of being single-threaded like Ruby MRI.

Crystal has been used in production at Manas (the sponsor company), 84codes, and by several European fintechs; the community is small but stable. Crystal’s greatest challenge is competing for mindshare against Ruby (which has adopted RBS/Steep for static typing) and against Kotlin/Go (which offer similar ergonomics with much larger ecosystems).

2.11 Pony (Sylvan Clebsch and team; Imperial College London; 2015)

Pony is an actor-model, statically-typed, garbage-collected systems language whose most novel contribution is reference capabilities: every reference in Pony carries a capability that constrains what may be done with it, including iso (isolated, unique), trn (transition), ref (read/write, single-actor), val (immutable, sharable), box (read-only), and tag (opaque). The capability system statically prevents data races by ensuring, at compile time, that mutable state can only be reached from one actor at a time (Pony documentation and community summaries). Pony also uses per-actor tracing garbage collection with cycle detection across actors — a genuinely novel GC design.

Pony has remained a research and niche-production language, but its reference-capability idea has been highly influential on later capability-oriented languages (Austral, Verona).

Deny capabilities. A related concept in Pony is deny capabilities: a reference capability can deny certain uses of the underlying data even to code that would otherwise be permitted to touch it. This is the mechanism by which Pony statically proves that no two actors ever hold mutable references to the same data — a stronger property than Rust’s Send/Sync because it is enforced by the type system across actor boundaries with no runtime cost.

Actor GC. Pony’s actor-model GC (“ORCA” — Ownership and Reference Counting for Actors) uses per-actor tracing GC combined with an inter-actor reference-counting protocol, with a distributed cycle detector for cross-actor cycles. This is one of the more novel GC designs of the modern era; the design paper (Clebsch, Franco, Drossopoulou, Blessing, McNeil, 2017) is a good entry point.

2.12 Idris 2, Agda, Lean, Coq → Rocq — the dependent-type family

Idris 2 (Edwin Brady; 2019 rewrite). Idris 1 (Brady, 2011) was one of the first pure-functional languages with full dependent types designed explicitly for practical programming rather than proof. Brady rewrote it as Idris 2 in Idris itself (bootstrapped through Chez Scheme) starting around 2019; Idris 2 is based on Quantitative Type Theory (QTT), in which every binding carries a quantity (0, 1, or ω) tracking whether it may be used at runtime, exactly once, or many times (Idris official site; Brady’s papers on QTT). QTT unifies erasure (0-quantity), linearity (1-quantity), and normal use (ω-quantity) under a single mechanism — a design contribution likely to influence future dependently-typed languages.

Agda. Agda (Ulf Norell, Chalmers, 2007–) has matured through the 2010s as the leading dependently-typed proof assistant with a first-class programming interface. Its tactic-free, direct-manipulation style — the user constructs proof terms by pattern matching, guided by “holes” in an interactive Emacs mode — has strongly influenced Lean and the modern Coq/Rocq UI (Agda documentation).

Lean and mathlib. Leonardo de Moura started Lean at Microsoft Research in 2013 as a project to build a next-generation theorem prover; Lean 4 was released in 2021 after a five-year rewrite (Lean overview, lean-lang.org; Leanprover Github page). Lean 4 is unusual in being both a proof assistant and a general-purpose functional programming language: it has a compiler (bootstrapped in itself), a native runtime, hygienic macros as a first-class metaprogramming mechanism, and dependent types. The mathlib community library, run collaboratively by mathematicians, has grown to over a million lines of formalized mathematics by 2024–2025 and is now used in projects that formalize state-of-the-art mathematics results (Terence Tao’s polynomial Freiman-Ruzsa conjecture proof, 2023) (Lean mathlib community).

Lean’s compiler design. Lean 4 is one of the more interesting practical compiler designs of the era: the compiler is written in Lean itself, uses a novel hygienic macro system (macros return elaborated terms, not just token trees), targets C code that is compiled by a system C compiler, and uses a reference-counted memory model whose refcount operations are elided by whole-program analysis where possible. The result is that Lean 4 produces code that is competitive with OCaml on many benchmarks, while also being a proof assistant.

Coq → Rocq (2024 rename). Coq (Thierry Coquand’s initials + French for “rooster”) has been in continuous development at Inria since 1989. In 2024 the project renamed itself Rocq — pronounced the same way, and playing on the older French pronunciation — after years of discussion about the fact that “coq” is French slang with an obscene meaning in English. The rename was announced formally in early 2024 with a new domain and new logo; version numbering restarted from 9.0 as the first “Rocq” release (Rocq official site; Coq community org). The migration was intended to be low-friction: the internal ML code and .v file format did not change.

Coq’s most notable production deployments include the CompCert verified C compiler (Xavier Leroy, Inria, ongoing since 2005), which is used in avionics and railway signaling and which produced a formal proof that its optimizer preserves the semantics of source C programs down to assembly. CompCert is one of a small number of examples in software engineering of an artifact that has been formally proven correct at industrial scale.

2.13 Racket and language-oriented programming

Racket (Matthias Felleisen and the PLT group, born from PLT Scheme in 2010) has spent the 2010s and 2020s as the definitive laboratory for language-oriented programming (LOP). The Racket #lang mechanism lets a file declare, on its first line, the language in which its body is written; the language is any Racket module that exports a reader and a semantics. Racket ships with dozens of #langs, and users routinely build small domain-specific languages (Racket documentation and community). In 2021 the Racket team switched the default runtime from the original C-based one to a port hosted on Chez Scheme (“Racket CS”), producing significant performance improvements.

Racket’s teaching lineage is important context: the language and its predecessors (PLT Scheme, DrScheme) were designed as pedagogical tools, and the book How to Design Programs (Felleisen, Findler, Flatt, Krishnamurthi) has been used as a first programming text at many universities. The pedagogical framing has kept Racket’s core small even as #lang extensions have multiplied: the base language is stable, but the language space above it is unbounded.

Typed Racket. Typed Racket (Sam Tobin-Hochstadt) adds a gradual, occurrence-typed type system to Racket, using a form of flow typing that refines a variable’s type based on the branches of predicate checks. The occurrence-typing style has influenced TypeScript and Flow. Typed Racket is one of the few genuinely production-usable gradually-typed languages.

2.14 Reason, ReScript, and the OCaml-on-JS lineage

Reason (Jordan Walke and team; Facebook; 2016). Jordan Walke — the creator of React — designed Reason as an alternate syntax for OCaml that would be more familiar to JavaScript programmers, plus a toolchain for compiling OCaml to JavaScript via BuckleScript. Facebook used Reason internally for Messenger.com and other products (Reason ML).

ReScript (2020 rename/split). In 2020 the BuckleScript project renamed itself ReScript and forked the ecosystem, positioning itself as a JavaScript-first ML dialect that no longer tracked upstream OCaml. The design philosophy shifted from “OCaml on JS” to “a fast, typed language whose output is idiomatic JavaScript” (ReScript documentation).

ReScript’s decisions to (a) diverge from OCaml, (b) drop the objects-and-functors layers of OCaml in favor of records-and-modules only, and (c) design its own syntax rather than reusing OCaml’s proved highly controversial in the OCaml community but produced a language that is genuinely approachable to JavaScript developers. ReScript’s user base has stabilized around teams that need typed React development with better ergonomics than TypeScript.

2.15 Ceylon, Xtend, Whiley — the also-rans

Ceylon (Gavin King; Red Hat; 2011–). Gavin King (creator of Hibernate) designed Ceylon as a JVM language with union and intersection types, a modular type system, and a distinctive flow-sensitive narrowing based on is checks. Ceylon 1.0 shipped in November 2013; Red Hat wound down the project around 2017 and transferred it to the Eclipse Foundation as “Eclipse Ceylon,” where activity declined further (Wikipedia: Ceylon language, and Eclipse handoff summaries). Ceylon’s design ideas (particularly union types) directly influenced TypeScript and later Scala 3.

Xtend (Eclipse Foundation). Xtend is a JVM language built on Xtext (a parser-generator infrastructure) with a Kotlin-like feature set — extension methods, type inference, template expressions — but a tighter Eclipse tooling integration.

Whiley (David Pearce; 2010). Whiley integrates a static verifier into an imperative language with structural types, constraints on function parameters, and preconditions/postconditions; its verifier can prove absence of runtime errors like divide-by-zero or array out-of-bounds. Whiley remains an academic project.

2.16 Vala and Genie (GNOME)

Vala (Jürg Billeter and Raffaele Sandrini, GNOME project, 2006–) is a C#-inspired language that compiles to C code targeting the GObject type system. Genie (Jamie McCracken, 2008–) is a Python-syntax variant of the same compiler. Both languages have been used to write GNOME applications (Geary email client, Elementary OS apps, GNOME Games), but adoption has plateaued in the 2020s as Rust has become the preferred systems language in the GNOME ecosystem.

2.17 Fantom, Nim, and other alternative-syntax mainstream languages

Nim (Andreas Rumpf; 2008–, 1.0 in 2019). Nim is a Python-syntax, statically-typed, compiled language that transpiles to C, C++, JavaScript, or Objective-C. Its distinctive features are compile-time function execution (like Zig’s comptime), a hygienic macro system, and a novel memory management system (ARC-plus-cycle-detection or fully-manual, chosen per-project). Nim has a small but committed production community; Status.im uses Nim for its Ethereum consensus client.

Fantom (Brian and Andy Frank; 2005–2015 development, low activity since). Fantom is a JVM/.NET/JS language that predated many of the modern conveniences but which never gained meaningful adoption; it is included here mainly as an example of a well-designed language that missed its window.

Red (Nenad Rakocevic, 2011). Red is a Rebol-inspired language whose ambition is to be a full-stack language from bare metal to reactive UI; the project has been active but has never reached 1.0.


3. ERA 8 — The Late 2010s and Early 2020s: Verification, Effects, Capabilities, and the Systems Revival

3.1 Zig (Andrew Kelley; 2016–)

Origins and philosophy. Andrew Kelley started Zig in 2016; the first public release was in early 2016, and by 2024 the project had accumulated significant industry attention (notably from the Bun JavaScript runtime, which is written in Zig). Kelley designed Zig around the principle of no hidden control flow: every allocation, every possible failure, every panic must be visible at the call site (Zig official site; Zig learn overview; Andrew Kelley: intro to Zig). The corollaries are strict: no exceptions (Zig uses error-union return types !T), no hidden allocations (allocators are always explicit parameters), no operator overloading, no destructor invocations at scope exit that the reader cannot see (except explicit defer).

Comptime. Zig’s most novel feature is comptime — arbitrary code that runs at compile time and can inspect and generate types. Generic containers are ordinary functions that take types as parameters and return types; there is no separate generic type system. comptime subsumes what C++ uses templates, macros, and constexpr for, and what Rust uses generics, procedural macros, and const fn for (Zig learn overview).

Implementation. Zig originally used LLVM as its only backend; from about 2022 the project has been building a self-hosted backend that compiles Zig directly to machine code for x86_64, aarch64, and WebAssembly, targeting fast debug builds and eliminating LLVM as a hard dependency (Zig 0.11.0 release notes). The Zig compiler is written in Zig (self-hosted from 0.10 onward for the front-end, gradually across releases for the backend).

Package manager. Zig shipped an official package manager in 0.11 (August 2023) after years without one; the manifest lives in a build.zig.zon file and uses content-addressed hashes rather than a central registry (Zig 0.11.0 release notes). In 2024 Zig also removed the language-level async/await from the compiler and postponed the design (Zig 0.11+ release notes and community discussion).

C interoperability. Zig can @cImport C header files directly and compile them as part of a build; the zig cc command turns the compiler into a drop-in C/C++ cross-compiler for any target LLVM supports. This capability has made Zig a popular build tool for C/C++ projects even for developers who never write Zig code.

Bun and industry adoption. Bun (see §5.5) is the highest-profile production user of Zig: the JavaScript runtime is written entirely in Zig and has demonstrated that Zig can be used to ship a widely-used production system. TigerBeetle (a distributed financial ledger) is also written in Zig. Uber has used Zig for parts of its Java build tooling.

Lasting influence. Zig’s philosophy that language features should not hide behavior — no exceptions, no hidden allocations, no operator overloading — has become a rallying point for a school of systems programmers who see Rust as too “high-magic.” The comptime mechanism has been widely admired.

Open questions. Zig has no memory-safety guarantees at compile time in the way Rust does; runtime debug-mode safety (bounds checking, undefined-behavior sanitization) is on by default but release-mode Zig can UAF like C. The 2024 removal of language-level async left Zig without a first-class concurrency story pending a redesign. Zig has intentionally not committed to 1.0 as of 2026 — the compiler team is prioritizing correctness of language semantics over adoption momentum, which some potential production users find frustrating.

3.2 Koka, Eff, Frank, Multicore OCaml — the algebraic-effects family

Algebraic effects. Algebraic effects and handlers are a foundational effect-system technique developed in the 2000s by Gordon Plotkin, John Power, and Matija Pretnar. An effectful operation (e.g., read : string) is invoked by user code but interpreted by an outer handler that specifies its semantics. The result is a lighter-weight, composable alternative to monads and monad transformers (Eff language and papers by Bauer and Pretnar; Koka book, algebraic effects chapter).

Koka (Daan Leijen; Microsoft Research; 2012–). Koka is a research language by Daan Leijen (Microsoft Research) that has been the primary vehicle for pushing algebraic effects into a practical language. Koka’s type system tracks effect rows: a function’s type includes not only its arguments and return type but also the set of effects it may perform. The compiler infers effect rows and rejects programs that fail to handle declared effects. Koka has developed evidence-passing translation as a practical implementation of handlers, avoiding the overhead of continuation-capture in the common case (Koka book; Koka documentation).

Eff (Andrej Bauer and Matija Pretnar; 2010–). Eff was the first language designed explicitly around handlers of algebraic effects and remains the reference implementation for teaching the concept (Eff site).

Frank (Sam Lindley, Conor McBride, and team; 2017). Frank generalizes handlers to a “do-be-do-be-do” model in which effectful computations, values, and handlers all inhabit the same syntactic category (“computations”). Frank’s most influential contribution is the shallow handler model, in which each handle clause continues by re-invoking the handler on the resumed computation (Frank papers, ICFP 2017).

Multicore OCaml → OCaml 5 (December 2022). OCaml 5.0 (December 16, 2022) was one of the most anticipated language releases of the decade: it merged multicore support (parallel execution on multiple threads sharing a heap) and effect handlers into mainstream OCaml, after roughly a decade of research and engineering led by KC Sivaramakrishnan, Stephen Dolan, Tom Kelly, and Anil Madhavapeddy at OCaml Labs (Cambridge) with support from Tarides, Inria, and Jane Street (OCaml 5 effects manual; Multicore OCaml paper; OCaml 5.0 release notes). Effects in OCaml 5 are un-typed at the language level (a design compromise to avoid whole-program effect inference); typed effects are expected in a later release.

The importance of OCaml 5 is that it made algebraic effects a shipping feature of a mainstream language — a proof point cited by many later language-design conversations.

OCaml 5 also demonstrated that a language could add both parallelism and effect handlers together with mostly backward-compatible source code — a nontrivial engineering feat, given that the OCaml GC had assumed a single-threaded mutator since 1996. The pre-5.0 minor-heap-per-domain design and the new concurrent major heap were the product of a decade of research and implementation work by the OCaml Labs group.

Effect handler use cases. In OCaml 5 effect handlers are used to build user-space fibers (see eio, the modern OCaml effect-based IO library), to implement generators, to model lightweight exception-like control flow with resumption, and to build clean isolation boundaries between library and application code. The primary limitation is that effects are dynamically typed — an unhandled effect at runtime raises a Stdlib.Effect.Unhandled exception rather than being caught at compile time. Typed effects (“typed effect handlers”) are on the OCaml roadmap but not yet shipped.

3.3 Unison (Paul Chiusano and Rúnar Bjarnason; 2015–)

Unison is a Haskell-inspired pure functional language with two distinctive design choices. First, content-addressed code: every function is identified by a hash of its (normalized) syntax tree, not by a name. Names are metadata that point at hashes; renaming is a trivial operation, and two functions with different names but identical bodies simply share a hash. Version conflicts become impossible: two crates that use different versions of the same library are simply calling functions with different hashes, and they can coexist in the same program (Unison “the big idea”; Unison official site). Second, abilities — Unison’s name for algebraic effects — are a first-class part of the type system, tracked in function types just as in Koka.

Unison’s design implications are large. Because code is content-addressed, code can be sent over the wire and executed remotely with a compact hash-based reference; the Unison team has built a distributed-computing capability on this foundation. The registry (Unison Share) is a code-repository/marketplace where users publish content-addressed code rather than versioned packages.

Unison remains a small but active language with a devoted following; the design ideas — especially content-addressing — have influenced Nix, IPFS-based language experiments, and academic proposals for “immutable programming” (Content-addressed code survey covers Unison and Nix).

Unison Share and Unison Cloud. In 2023 the Unison team launched Unison Cloud, a hosted execution platform on which content-addressed Unison programs can run without conventional container packaging: because every function is identified by hash, deploying an application is a matter of sending the root hash to the platform. The company (Unison Computing) has raised seed funding and continues to develop the platform.

Implementation notes. Unison compiles to bytecode executed by a JVM-hosted runtime (Racket-hosted in the older versions), with a JIT-compilation path for hot code. The content-addressed identifier for a function is computed on the normalized AST, meaning \x -> x + 1 and \y -> y + 1 produce the same hash — alpha-equivalent code has identical identity.

3.4 Roc (Richard Feldman; 2019–)

Richard Feldman (a prominent Elm developer and podcaster) started Roc as a “successor to Elm” that would extend the design to server and CLI use cases. Roc is pure functional, statically typed, with static dispatch (no dynamic dispatch, no interfaces at runtime), and — most distinctively — a platform architecture: the Roc program does not talk to the OS directly; instead each application is written against a platform (a Rust or Zig or C library that provides IO effects and calls into the Roc program) (Roc official site; Roc FAQ).

Roc’s compiler is written in Rust; its GC is a Perceus-style reference-counting scheme that (thanks to whole-program analysis) elides refcount operations for stack-only values. Roc’s syntax and semantics are Elm-derived (algebraic data types, record types, pipe operator). As of 2025 Roc has not reached 1.0 but has a growing production user base for CLI tools and small services (Roc official site and release status pages).

Abilities. Roc’s version of algebraic effects is called abilities: a function that reads from a file must be typed with the Read ability, and the platform (not the language) provides the concrete implementation. The design is a nice example of “capabilities as effects” — platform-provided abilities give the language its IO story without needing an IO monad or a full effect-row inference system.

The platform architecture. The Roc platform model is worth studying as a language-design idea. Rather than have the language link to libc or shell out to OS APIs, every Roc program specifies which platform it targets (basic-cli, basic-webserver, basic-tui, etc.); the platform is a native (Rust/Zig/C) library that provides IO and effect handlers and calls into the Roc application code as a callback. The result is that Roc code is maximally portable — the same Roc source runs on servers, CLIs, embedded targets, or WebAssembly by choosing a different platform — while remaining fully typed and safe.

3.5 Grain (Oscar Spencer and Philip Blair; 2019–)

Grain is an ML-family functional language whose distinguishing property is that it is WebAssembly-first: it compiles directly to WebAssembly, has no other backend, and is designed to interoperate with the WASI and WebAssembly Component Model ecosystems (Grain official site). Its design borrows from OCaml (variants, pattern matching, records) with a more approachable syntax.

Grain’s design is interesting because it treats WebAssembly not just as a compilation target but as the runtime: there is no assumed OS, no assumed heap layout, just what WASI provides. The trade-off is that Grain has no path to native execution independent of a Wasm engine — which is either a feature (portability, security sandboxing) or a limitation depending on the use case.

3.6 Gleam (Louis Pilfold; 2016–, 1.0 in March 2024)

Gleam is a statically typed language for the BEAM (Erlang) VM, in the same niche as Elixir but choosing a fully static, ML-family type system rather than Elixir’s dynamic core. Louis Pilfold began the language in 2016; Gleam 1.0 was released on March 4, 2024, marking the first stable typed language on the BEAM (Gleam 1.0 release announcement, March 2024; Gleam official site). The type system uses Hindley-Milner-style inference with algebraic data types and a novel actor/mailbox typing scheme.

Gleam’s most distinctive design choice is its focus on being small — the language has no macros, no type classes, no higher-kinded types, no complicated inheritance, and a stated goal of being learnable in a weekend. This is a deliberate contrast to Elixir (macro-heavy) and to Haskell/Scala (type-system-heavy). The Gleam compiler emits both BEAM bytecode and JavaScript, allowing a Gleam library to run on both the server (BEAM) and in the browser without conditional code.

Gleam’s adoption has been steady since 1.0; the language has attracted teams that want typed BEAM code, want a smaller learning surface than Elixir, or want to run the same code on both Erlang/OTP and Node.js. Louis Pilfold funds Gleam development through GitHub Sponsors, an unusual sustainability model for a language project.

3.7 Austral (Fernando Borretti; 2018–)

Austral is a systems language whose central design decisions are linear types (every value must be used exactly once) combined with capability-based effects (permission to perform IO, allocate memory, etc. is passed as a value). Borretti describes the design as an attempt to build a “small, safe, boring” language: the type system is deliberately monomorphic in features rather than adding many convenient abstractions (Introducing Austral, borretti.me, 2022; Austral official site).

Austral’s capability system means that a function that reads a file must be passed an explicit FileReadCapability; a function without such a capability cannot read files, and cannot silently call a function that does. This gives supply-chain security by construction — a language-level answer to the class of attacks that malicious npm dependencies enable.

Austral remains a research/hobby language, but its combination of linear types with capabilities is one of the cleanest expressions of the “capability-safe systems language” idea.

Deliberately “small.” Borretti has been explicit that Austral’s target audience is safety-critical embedded and systems programming — spaces where the trade-off of learning a stricter language for stronger correctness guarantees is worth it. The language does not chase Rust’s ergonomics; it accepts more verbose code in exchange for a smaller, simpler, more auditable formal semantics.

3.8 Vale (Evan Ovadia / “Verdagon”; 2019–)

Vale is a memory-safe systems language that combines regions (a region is a set of allocations with a shared lifetime), generational references (a heap reference is a pair of (pointer, generation number); dereferencing checks that the generation still matches, and either the check is elided by the compiler or it becomes a small runtime check), and Higher RAII (the destructor of a value can require it to be handed off to a specific consumer, rather than silently dropped) (Vale official site).

The generational-reference technique is a genuinely novel memory-safety mechanism: it gives memory safety without a tracing GC and without the analysis burden of Rust’s borrow checker, at the cost of a small (often elided) runtime check. Vale has been used as a testbed for compiler research on region-based memory management.

Higher RAII. Vale’s Higher RAII is a distinctive feature: a destructor can require that the value be handed off to a specific consumer (e.g., a Transaction that must be explicitly .commit() or .rollback()), rather than silently invoking a default cleanup. The type system rejects programs that drop a Higher-RAII value without calling one of its terminal methods. The design has been influential on other capability-oriented languages.

Regions in Vale. Vale’s region system lets code temporarily promote a value into a pure region, in which no code can mutate the outside world, enabling parallel execution and cache-friendly data-oriented layouts. The design is a middle ground between Rust’s &mut borrow (which is exclusive but non-parallel) and functional languages’ immutable data (which is parallel-safe but requires copying to mutate). Verdagon has documented the design extensively in blog posts on vale.dev.

3.9 Hylo (Dimi Racordon and team; formerly Val; 2022–)

Hylo (renamed from Val in 2023) is a systems language designed by Dimi Racordon (EPFL), Dave Abrahams (formerly Apple/Swift), and Sean Parent (Adobe). Its central design contribution is mutable value semantics: every value in the language behaves as though it were independently owned; sharing is expressed through projections and subscripts — accessors that borrow parts of a value under strict rules (Hylo official site). The result is a language with the reasoning simplicity of pure functional programming but the performance profile of C++ (in-place mutation, no ARC-style refcount, no GC).

Hylo’s subscripts and projections generalize C++‘s references and iterators; the semantics are formalized in a research paper published in 2022. Hylo remains pre-1.0 in 2026 but the design is influential.

Mutable value semantics as a design bet. The Hylo team argues that mutable value semantics gives the simplicity of reasoning of pure functional programming (every function’s behavior is fully described by its arguments and return value) while retaining the performance profile of C++ (in-place mutation is fine, since the value is uniquely owned at the point of mutation). This is a distinct point in the memory-safety-without-GC design space, and it interacts with generics differently than Rust’s ownership model does.

Sean Parent, one of the language’s co-designers, has given a series of talks (“Better Code: Runtime Polymorphism”, “Value Semantics and Concept-Based Polymorphism”) over more than a decade arguing that C++‘s reference and iterator misuse is the root cause of most memory-safety bugs — Hylo is in one sense the outcome of applying that critique to a full language design.

3.10 Carbon (Google; 2022–)

Google’s Carbon Language was announced at CppNorth 2022 by Chandler Carruth as an experimental successor language for C++ that preserves bidirectional interoperability. The stated goal is that a large C++ codebase should be able to migrate file-by-file to Carbon without rewriting the world (Carbon official site; Carbon project goals). The design philosophy differs sharply from Rust: Carbon accepts a garbage collector or manual memory management (rather than Rust’s borrow checker), keeps C++‘s memory model, and aims for “boring” familiarity.

As of 2026 Carbon is still in the 0.x phase — the team is explicit that Carbon is a research/experimental project not ready for adoption (Carbon project status).

Design philosophy contrast with Rust. The Carbon team’s design assumptions differ sharply from Rust’s. Where Rust chose memory safety at any cost — with a steep learning curve and slower compile times as the price — Carbon chooses migration path from C++ at any cost. Carbon programs may hold raw pointers, may leak memory, may have use-after-free bugs; the language does not promise memory safety. Instead the design bet is that Carbon can improve on C++‘s ergonomics (better generics, better error handling, better modularity) while remaining bidirectionally interoperable with existing C++ code, so that a large C++ codebase can migrate incrementally to a better C++ rather than jumping to a fundamentally different language.

Whether this bet pays off depends on whether the C++ industry actually wants to migrate to a better C++ or would rather stay on C++ itself. As of 2026 the answer is unclear — Carbon has significant Google investment but limited outside adoption.

3.11 Cppfront (Herb Sutter; 2022–)

Cppfront is Herb Sutter’s experiment in syntax-2 for C++: a cleaner, statement-terminated, function-first syntax that compiles down to standard C++. Cppfront is not a new language but a translator that emits C++ code, so any Cppfront program has full C++ interoperability by construction. The project shows what a modern surface syntax for C++ might look like without breaking the standards process (Cppfront GitHub repository, various).

3.12 Odin, Jai, Beef — the Zig-adjacent systems languages

Odin (Ginger Bill; 2016–). Odin is a systems language with C-like performance, manual memory management via context-passed allocators, tagged unions, distinct types (nominal typing), and first-class support for SoA (structure-of-arrays) layouts. Its design philosophy is close to Zig’s — no hidden control flow, explicit allocators — but with a more Pascal-adjacent syntax and a heavier focus on game and graphics programming (Odin official site; Wikipedia: Odin). Odin has been used to ship the EmberGen fluid-simulation software (JangaFX).

Jai (Jonathan Blow; 2014–). Jonathan Blow (creator of Braid and The Witness) has developed Jai in public via streaming since 2014. Jai emphasizes compile-time code execution, data-oriented design, and low ceremony. As of 2025 Jai is in closed beta with an invitation-only compiler; a public release has not yet happened (Jai community summaries, no official website).

Beef. Beef is a C#/C++-inspired systems language with a Rider-like IDE, generational garbage collection, and a focus on fast iteration for game development (Beef community pages).

3.13 Mojo (Modular / Chris Lattner; 2023–)

Mojo was announced by Modular Inc. on May 2, 2023 as a Python-superset language for AI. Chris Lattner (LLVM, Clang, Swift) and Tim Davis founded Modular in 2022 explicitly to solve the fragmentation of the AI stack (Python + CUDA + XLA + PyTorch + TF + ONNX + …). Mojo is designed to be a superset of Python — a Python program is a valid Mojo program — while adding first-class static typing, ownership (borrowed/owned), value semantics, SIMD-native types, and a metaprogramming system based on MLIR (Mojo announcement, Modular blog; Mojo manual).

MLIR-nativity is Mojo’s central technical bet: rather than treating GPUs, TPUs, and accelerators as an afterthought, Mojo has direct access to MLIR dialects at the language level, and the Modular team has framed the opportunity as “the $3 trillion” AI infrastructure market — the total addressable market they claim to be targeting through Modular’s platform (Modular blog and Mojo manual).

Mojo went open-source (Apache 2 with runtime exception, in phases) during 2024–2025, having previously been available only through Modular’s SDK. As of 2026 Mojo is one of the highest-profile “AI-era” languages, though its Python-superset promise remains partially realized (some Python idioms are not yet supported).

Modular raised a 100 million Series B in August 2023 at a valuation reported around 600 million, and additional funding through 2024–2025 has kept the company well capitalized. The pitch to investors has been that AI compute is a large and fragmented market where a common compilation and runtime infrastructure could capture significant value — hence Lattner’s often-quoted framing of the opportunity as “the $3 trillion market” for AI infrastructure over the next decade (Modular blog, Mojo overview and manual, various; Mojo announcement, Modular blog, May 2, 2023).

Design bets. Mojo’s technical bets:

  1. Python-superset compatibility eliminates the migration cost that killed many prior “Python replacement” languages (Nim, Cython for the whole language, PyPy for the JIT). Every Python program is a valid Mojo program.
  2. MLIR-native means Mojo compiles down through MLIR dialects, and users can define custom MLIR dialects for accelerators (GPUs, TPUs, dataflow processors) without waiting for compiler-team support.
  3. Explicit ownership borrowed from Rust (borrowed T, owned T, and Mojo’s newer read/mut/inout argument conventions) but designed to interoperate with Python’s reference-counting semantics for compatibility.
  4. SIMD as a first-class type — SIMD[DType.float32, 8] is a normal value type; there is no separate intrinsic-function layer.
  5. Comptime metaprogramming similar to Zig’s but subtly different: Mojo has a stricter separation between statically-typed values usable at compile time and dynamic Python objects at runtime.

Adoption dynamics. Adoption in 2024–2026 has been driven by Modular’s own products (the MAX inference platform, Max Serve) and by AI/ML infrastructure teams that need custom operators for models. Whether Mojo can win over the general Python ecosystem — in particular the ML frameworks that already exist (PyTorch, JAX) — is the central open adoption question.

3.14 Bend, Vine, Kind and HVM — interaction-nets on the GPU

HVM (Higher-order Virtual Machine). HVM is a runtime for interaction combinators — a Turing-complete graph-rewriting model due to Lafont (1990) — implemented on the GPU. Bend (2024) is a Python-syntax language that compiles to HVM and runs automatically in parallel on the GPU without the programmer writing any parallelism-specific code (HigherOrderCO / Bend GitHub, various). Vine and Kind are related languages from the same team; Kind is a dependent-type proof assistant that also compiles to HVM.

The demonstration that a functional language can compile to GPU-parallel interaction nets and get near-linear scaling has been striking, though the practical language is still small.

3.15 Lamdera, Effekt, Ante

Lamdera is a distribution of Elm that adds full-stack semantics: a frontend/backend split with automatic wire-protocol generation and hot code migration (Lamdera site and community summaries). It is a case study in what a batteries-included, opinionated “web framework as a language” can look like.

Effekt (Jonathan Brachthäuser and team; 2019–). Effekt is a research language that combines algebraic effects and handlers with a novel lightweight effect polymorphism — the goal is to avoid the “effect row” boilerplate of Koka while retaining effect tracking (Effekt research pages and papers).

Ante (Jake Fecher; ongoing). Ante is a research language exploring the intersection of algebraic effects, region-based memory management, and refinement types.


4. ERA 9 — The AI Era (2023–2026)

4.1 The AI turn: grammar-constrained decoding and the “LLM-first” language question

The single most consequential language-technology development of 2023–2026 was the mainstreaming of grammar-constrained decoding — techniques that constrain a large language model’s next-token distribution to only those tokens that are consistent with a formal grammar (JSON schema, EBNF, regular expression, or the grammar of a programming language itself).

PICARD (October 2021). PICARD, published at EMNLP 2021 by Torsten Scholak and colleagues at ElementAI, was one of the first practical grammar-constrained decoding schemes, applied to SQL generation from natural language. Its acronym expands to Parsing Incrementally for Constrained Auto-Regressive Decoding; the technique parses the LLM’s proposed continuation incrementally and rejects tokens that lead to unparseable SQL (PICARD paper, EMNLP 2021, arXiv:2109.05093). PICARD was a research prototype but demonstrated the principle that a parser attached to the decoding loop could dramatically improve syntactic and even semantic validity of generated code.

Outlines (2023–). Outlines, developed by Rémi Louf and dottxt.ai, made grammar-constrained decoding a widely used library. Outlines compiles a regex or context-free grammar into a finite-state machine over the tokenizer’s token IDs, letting the model’s logits be masked at each decoding step to only permit tokens that keep the FSM alive (Outlines documentation, dottxt-ai.github.io). By 2025, Outlines was used by many production LLM inference stacks (vLLM has an Outlines integration).

SynCode. SynCode is a technique for constraining LLM decoding to syntactically valid programs of a target language by combining an offline-computed LR parser state with online logit masking. It was released in 2024 as a paper and open-source library and demonstrates the same principle scaled to full programming-language grammars (SynCode paper and repo, 2024).

XGrammar (NVIDIA, 2024). XGrammar is a high-performance grammar-constrained decoding backend developed at Carnegie Mellon and later adopted by NVIDIA TensorRT-LLM. It uses pushdown-automaton state caching and per-token bitmask precomputation to reduce grammar-checking overhead to near-zero in the fast path (XGrammar release notes and blog, 2024). XGrammar is now the default constrained-generation backend for many production inference stacks.

Guidance (Microsoft, 2023–). Guidance is Microsoft’s structured-output library that provides a small DSL for specifying constrained generation programs (including regex, context-free grammar, and stateful branching). Guidance’s design philosophy is that the LLM should be programmed as a step-by-step state machine rather than a single-prompt call (Guidance GitHub repository, various).

The token-boundary problem. A subtle challenge in grammar-constrained decoding is that LLM tokens do not align with the symbols of a language grammar. A single BPE token might contain multiple characters that straddle grammar rules (e.g., a token ") { in Python that ends one production and begins another). Solving this requires token-level grammar reasoning: the constraint system must maintain, for each possible next token, whether that token’s characters would keep the grammar satisfiable. Outlines, XGrammar, and SynCode all use variations on this idea, generally precomputing per-state-per-token bitmasks that can be applied to the LLM’s logits in a single vectorized operation.

Why this matters for language design. Grammar-constrained decoding makes some traditional language-design tradeoffs disappear and creates new ones. A language whose grammar is LL(1) or LALR(1) — parseable with one token of lookahead — is trivially compatible with all major constrained-decoding libraries; a language with an ambiguous grammar (Perl, some C++ constructs) is not. Languages with statement terminators (Rust, Go, Zig, TypeScript with strict mode) are easier for LLMs to emit incrementally than indentation-sensitive languages (Python, Haskell, Nim), because a semicolon or brace is an unambiguous “commit” signal that lets a partial generation be validated. Languages with single obvious solution — one canonical way to do a thing — reduce the search space over which the LLM has to disambiguate and produce more consistent outputs across prompts (Multiple 2024–2025 blog posts on LLM-friendly language properties from language communities).

Other properties that improve LLM code generation:

  • Rich, machine-readable diagnostics. Rust’s --error-format=json, Julia’s structured Base.Meta.ParseError, Roc’s diagnostic protocol, and the TypeScript language server all emit diagnostics that an LLM autofix loop can consume without regex-parsing English error messages.
  • Stable module identity. Content-addressed modules (Unison, Nix, potentially any Wasm Component Model artifact) let the LLM reference a specific function by hash rather than by an unstable import path.
  • Explicit effect signatures. When a function’s type says IO, Async, Reads[File], or may throw, an LLM can reason about safety of a candidate call without executing it.
  • Small standard library with many high-quality third-party libraries vs. a large standard library. There is no consensus on which is easier for LLMs: some evidence suggests LLMs know standard-library APIs better (favoring “batteries included” languages), while other analyses suggest LLMs hallucinate less when there is one canonical library to use.
  • Unambiguous operator precedence. Languages that require explicit parentheses (Lisp) or that have a small, unambiguous precedence table (Rust, Go) generate more reliably than languages with heavy operator overloading (C++, Scala with symbolic method names).

Structured error messages — Rust’s colored diagnostics, Elm’s essays, Julia’s stack traces — become inputs for LLM-driven autofix loops rather than only for humans. Languages whose compilers emit machine-readable error diagnostics have a structural advantage in AI-assisted workflows.

4.2 GitHub Copilot, Cursor, and language ergonomics

GitHub Copilot was launched as a technical preview in June 2021 and became generally available in June 2022. Cursor (Anysphere), launched in 2023, is an AI-first fork of VS Code. By 2024 the practical experience of writing code in mainstream languages was mediated for many developers by an LLM autocomplete (Cursor and Copilot influence on ergonomics, various commentary, 2024–2025).

Two consequences have started to reshape language ergonomics. First, verbose imperative code — the kind that most annoyed language designers in the 2010s and drove Python’s popularity — has become cheap: the LLM writes it. Second, code that is unambiguous but slightly verbose is often easier for LLMs to generate correctly than code that is terse but requires deep context (long list comprehensions, monad transformer stacks). This has begun to bias the design conversation toward languages with explicit types (TypeScript over dynamic JS), explicit error handling (Rust’s Result, Go’s error returns, Zig’s error unions), and explicit lifetimes/scopes.

The autocomplete-shaped language. A quiet consequence of LLM-mediated development is that languages whose most-common patterns are also their most-canonical patterns generate more reliably. Consider Python: the LLM has seen millions of “open a file, iterate lines, close the file” snippets, so it produces a with open(...) block reliably. But Python has many equally-valid ways to spell a matrix multiplication (numpy.matmul, numpy.dot, @ operator, A @ B, np.einsum) — and the LLM’s completion depends on which library is in scope, which import alias is used, and which idiom matches the surrounding style. Rust and Go, with their smaller idiomatic surface, tend to produce more consistent LLM completions. This is not a claim that one language is “better” — it is a claim that language ergonomics for humans and language ergonomics for LLMs are not identical, and are beginning to diverge.

Copilot workspace and agentic loops. By late 2024 the tools had moved beyond single-line completion: Copilot Workspace, Cursor Composer, Cline, Aider, and other agentic tools now operate on whole repositories, planning multi-file changes, running the tests, and iterating on failures. This escalates the demand for machine-readable diagnostics (LLM reads compiler error, edits code, reruns) and for languages whose behavior is predictable across many small edits (avoiding whole-program-inference languages where a single edit can ripple).

4.3 Model Context Protocol (Anthropic, November 2024)

Anthropic announced the Model Context Protocol (MCP) on November 25, 2024, as an open standard for connecting AI assistants to data sources and tools (Anthropic MCP announcement; MCP introduction docs). MCP defines a JSON-RPC protocol over stdio, HTTP, or SSE by which a language model client can discover the tools, resources, and prompts offered by an MCP server; a tool is a typed function the model can call, a resource is data the model can read, and a prompt is a template that the human can invoke.

MCP became a rapidly-adopted standard through 2025: Claude Desktop, ChatGPT (via Zapier and native support), Windsurf, Cursor, Zed, and many IDE extensions have MCP client implementations, and the ecosystem of MCP servers has grown into the thousands (MCP introduction and community lists, 2025).

For language design, MCP matters as a formalization of tool authority and language boundaries: the language a program is written in becomes less important than the interface it exposes to the model. Systems languages, verified languages, and effect-typed languages all benefit from a common substrate for describing what a program can be asked to do.

MCP as an inter-language type system. MCP tool descriptions are JSON Schema documents describing typed function signatures. A Python MCP server, a Rust MCP server, and a TypeScript MCP server all export the same schema to any MCP-speaking client. This is functionally equivalent to a language-independent type system for tool calls — a role previously played (with varying success) by COM, CORBA, protobuf, and OpenAPI. What makes MCP different is that the client is an LLM, and the schema is used for prompting the LLM about available tools rather than for compile-time type checking. The design lesson is that the LLM has become the lingua franca between language ecosystems: two programs no longer need to speak the same source language, only the same tool schema.

MCP transport and lifecycle. The MCP transport specification supports three modes: stdio (subprocess-based, for local tools), HTTP with server-sent events (SSE), and streamable HTTP. The stdio transport has proven the most popular for local development because a client can spawn an MCP server as a subprocess and communicate over pipes without any networking configuration. Anthropic’s Claude Desktop client automatically discovers MCP servers from a JSON configuration file, making it possible for a user to add a new capability to their assistant by installing one npm/pip package.

4.4 Slopsquatting and package hallucination

Slopsquatting. In 2024–2025 security researchers documented a new class of supply-chain attack: LLMs, asked to write code, sometimes invent package names that do not exist; an attacker who registers the invented name on PyPI or npm can then run arbitrary code on any user who runs the LLM-generated code. The term slopsquatting was popularized by security researcher Seth Larson (PyPI’s security-in-residence) in 2024 (CSA report on slopsquatting, June 2025; CISA and PyPI security advisories, 2024–2025).

The xz-utils backdoor (March 2024). Even before the AI era made slopsquatting a household concern, the software-supply-chain conversation was already reshaped by the discovery of a two-year social-engineering attack on the xz-utils compression library. A single volunteer maintainer, burned out and overworked, was persuaded by a persistent (probably state-sponsored) attacker under the pseudonym “Jia Tan” to hand over co-maintainer rights; the attacker then merged a backdoor that would have compromised nearly every Linux distribution’s SSH daemon. It was caught by a Microsoft engineer, Andres Freund, who noticed a small performance regression in SSH connection times — seconds of latency — while benchmarking Postgres. The incident became the canonical example of the vulnerability of the single-maintainer open-source ecosystem to targeted social-engineering attacks.

Empirical rates. Multiple studies through 2024–2025 have quantified LLM package hallucination rates: figures in the 5–20% range appear across languages and models, with GPT-3.5-tier models hallucinating more often than the latest frontier models but no model achieving zero. The rate is worse for less-popular languages (Rust, Go had higher rates than JavaScript and Python in some studies, probably because there are fewer training examples). Slopsquatting attacks in the wild have been observed on PyPI (a package named huggingface_hub_downloader that mimicked the real huggingface_hub — the LLM invented the extended name), npm (React ecosystem typosquats), and RubyGems.

Countermeasures. The best response combines edit-time and install-time defenses. At edit-time, an LSP-integrated linter can verify that every import resolves to an actually-published package before code is committed. At install-time, package managers can require signed publishers (Rust’s Cargo has trusted-publishers-style OIDC signing; PyPI’s PEP 740 attestations; npm’s provenance signing), pin transitive dependencies by content hash (Go’s go.sum, Cargo.lock, Deno’s deno.lock), and warn the user when a package is fewer than N days old or has fewer than N downloads (the heuristic is imperfect but catches most slopsquats).

Slopsquatting sits inside a broader category of AI-augmented supply-chain attacks that also includes: (1) dependency confusion, in which an internal package name is shadowed by a public one; (2) typosquatting, in which similar-looking package names catch typos; (3) maintainer-account compromise (e.g., the 2024 xz-utils backdoor, which was a two-year social-engineering campaign against the sole maintainer); and (4) update-poisoning, in which a legitimate maintainer’s authenticated release contains malicious code. The LLM-era addition is that the victim never intended to import the attacker’s package at all — the LLM invented the name.

Empirical studies published in 2024 quantified the problem: one Bar-Ilan / University of Texas study found that between 5% and 20% of LLM-generated code samples imported non-existent packages, with the rate depending on the language and model. Slopsquatting attacks have been documented against PyPI (“huggingface_hub” typos), npm (React ecosystem), and RubyGems.

For language and package-manager designers this incentivizes several concrete responses: (1) content-addressed package identifiers (Unison, Nix); (2) mandatory checksum-verified imports (Go, Deno); (3) capability-restricted defaults (Deno’s --allow-net, --allow-read flags; Austral’s capabilities); and (4) edit-time validation via LSP that an imported name actually resolves before code is committed.

Beyond slopsquatting: the broader supply-chain design menu. A serious language-design response to supply-chain attacks now involves choices at every level:

  1. Identity of packages — human-readable names (npm, PyPI) vs. namespaced (Cargo has crates.io as a single global namespace but Elixir’s hex.pm has scoped org names) vs. content-addressed (Unison, Nix). The content-addressed approach eliminates typosquatting entirely (the hash is not typoable) but at the cost of unreadable references.
  2. Trust in publishers — unauthenticated (early npm) vs. account-authenticated (npm, PyPI today) vs. OIDC/trusted-publisher (Rust Cargo, PyPI’s trusted publishers PEP 740). The OIDC model ties publishing rights to a specific GitHub Actions workflow, dramatically reducing the impact of maintainer-account compromise.
  3. Runtime isolation of packages — no isolation (Python, JavaScript by default) vs. permission flags (Deno, Bun) vs. capability-typed (Austral, WebAssembly Components with typed imports). Isolation limits blast radius even after a compromised package is imported.
  4. Reproducibility — no lockfile (early npm) vs. lockfile (modern npm/Cargo/pnpm) vs. content-addressed builds (Nix, Bazel with remote caching). Reproducibility ensures that a build compromise is detectable by comparing hashes across builds.
  5. Vendoring / vendored dependencies — the practice of copying all dependencies into the project repository (common in Go, less common elsewhere). Vendoring gives auditability at the cost of update friction.

No language has yet integrated all five layers into a coherent design. A language built “for the AI era” has a genuine opening to do so.

4.5 The verification renaissance

Lean 4 mathlib has become the largest publicly available formal-mathematics library in history, crossing one million lines of Lean code in 2024 and attracting significant mainstream-math attention with Terence Tao’s 2023 formalization of the polynomial Freiman-Ruzsa conjecture (Lean mathlib community pages; Lean mathlib scaling reports, 2024–2025). AI-assisted proof search (Google DeepMind’s AlphaProof, various Copilot-for-Lean tools) has driven a step change in productivity.

F* (Microsoft Research and Inria) and its production deployments. F* is a dependently-typed language that combines effect-based reasoning with an SMT-based verifier. Its most significant production deployments include:

  • HACL* — a verified cryptographic library used by Mozilla Firefox’s NSS, the Linux kernel (WireGuard implementation), and the Python cryptography library (HACL* GitHub).
  • miTLS — a verified TLS implementation used as the basis for the QUIC protocol reference implementation and for verified cryptographic protocol proofs.
  • EverParse — a verified parser generator used inside Windows kernel components to parse network protocols with guaranteed absence of memory-safety bugs (EverParse production deployment summaries).

Dafny (Rustan Leino; Microsoft Research; ongoing). Dafny is a verification-aware imperative language whose compiler ships a Boogie-based SMT verifier. Amazon Web Services published in 2023 that they use Dafny internally to verify parts of their authentication and IAM code, marking one of the largest publicly-known deployments of a verified-language toolchain (Microsoft Research Dafny page).

Verus (Andrea Lattuada and team; 2022–). Verus is a verification framework for Rust: it lets Rust code be annotated with pre- and post-conditions and invariants, then dispatched to an SMT solver (Z3) to prove correctness. Verus preserves the ability to compile the same Rust code without the verification annotations for production, and it interoperates with cargo (Verus guide; Verus papers on arxiv). By 2024–2025 Verus was in use for verified parts of the AWS s2n-quic library and for internal Microsoft Research components.

Aeneas (Son Ho and team; Inria; 2022–). Aeneas is a novel approach to Rust verification: rather than reasoning about Rust code directly (with its ownership and borrows), Aeneas translates borrow-checked Rust into an equivalent pure functional program in F* or Coq/Rocq/Lean, where standard functional verification tools work naturally (Aeneas project pages). The technique — using the borrow checker as a proof of purity enabling pure-functional reasoning about impure code — is one of the more elegant verification ideas of the era.

4.6 Effect systems entering the mainstream

The 2020s have brought the effect-systems research programme into shipping languages:

  • OCaml 5 effect handlers (December 2022) — see §3.2.
  • Koka in production — Microsoft Research has documented internal use, and several companies (Lambdaclass has written about it) have started deploying Koka-based services (Lambdaclass blog on Koka).
  • Unison abilities — Unison’s ability system is production-ready and used by teams building distributed pipelines.

Meanwhile several 2020s general-purpose languages have adopted effect-adjacent designs: Roc’s abilities, Swift’s structured concurrency + SendingResult/Sendable isolation model, and Rust’s Send/Sync traits all use type-system machinery to constrain effects without full effect-row inference.

4.7 The capability revival

Object-capability languages — E (Mark Miller and team, 1997), Joe-E (Adrian Mettler et al., 2010), and their descendants — solved the confused-deputy problem by making authority explicit: to do something, you must hold a reference (a “capability”) that grants the authority. In the 2020s this idea has been revived across several languages:

  • Monte — a Python-inspired object-capability language descended from E, targeting concurrent secure systems (Monte language documentation, various).
  • Austral — see §3.7 — makes capabilities a first-class language feature.
  • Verona (Microsoft Research) — an experimental systems language whose capability system integrates with a novel region-based memory model.

The Cap’n Proto / CapTP lineage. Cap’n Proto (Kenton Varda) is a schema-first RPC and serialization system whose transport layer implements CapTP — the object-capability transport protocol descended from Mark Miller’s work on E. CapTP has been standardized and is used in production by Cloudflare Workers’ inter-worker messaging and by Sandstorm (Cap’n Proto documentation and CapTP references).

The capability revival has been reinforced by the AI era: with LLMs writing code that may call arbitrary functions, capability-based restrictions on what code can even attempt to do — rather than what it is allowed to do at runtime — become more attractive.

4.8 Content-addressed code

Unison — see §3.3 — remains the standard-bearer.

Nix. Nix is a functional package-manager and language whose central design is that every derivation (build result) is stored at a path determined by a hash of its inputs. This makes builds reproducible, cacheable across machines, and immune to entire classes of “works on my machine” bugs (Nix documentation). Nix flakes (introduced experimentally around 2020, still labeled experimental in 2024 but universally used) added a first-class notion of “input” that lets a flake pin all its dependencies by hash. Nix’s influence on the modern package-manager conversation has been substantial.

IPFS-based language experiments. Several research projects (Fluence, projects associated with the Ethereum ecosystem) have explored languages whose module resolution goes through IPFS content-addressed storage rather than a central registry.

Prusti and Creusot — two other Rust-verification tools — have continued to develop through the 2020s. Prusti (ETH Zurich) verifies Rust code with pre/post/invariant annotations using the Viper verification framework; Creusot uses Why3 as its backend and has been used to verify parts of the Rust standard library.

Kani (AWS). Kani, developed at AWS, is a bounded model checker for Rust that unrolls loops to a fixed depth and dispatches the resulting SMT problem to a solver. Kani has been used in production at AWS to verify parts of the Firecracker VMM and s2n-quic. Kani’s design contrasts with Verus/Prusti in that it is fully automatic (no human-supplied invariants needed) at the cost of being incomplete on unbounded programs.

Design ideas from the verification community that have influenced mainstream languages.

  • Rust’s ? operator (early motivation was verification-friendly error propagation).
  • OCaml’s effect handlers (motivated in part by making effectful code amenable to logical reasoning).
  • Swift’s Sendable protocol (verification-adjacent — the type system checks that shared state is safe to send across concurrency boundaries).
  • Kotlin’s contract DSL (contract { returns() implies (x != null) }) that lets library authors tell the compiler about branch conditions in a form that the smart-cast analysis can consume.

4.9 WebAssembly’s ascendancy

WebAssembly (Wasm) is the standardized, portable, low-level bytecode originally introduced in browsers around 2017 (Chrome, Firefox, Safari, Edge all shipped support in 2017). Its consequences for language design have grown steadily and became transformative in the 2020s.

WASI. WebAssembly System Interface (WASI) — a standardized “syscalls-for-Wasm” API that lets Wasm modules run outside the browser as portable secure sandboxes. WASI 0.1 was informal; WASI 0.2 (“Preview 2”) shipped in January 2024 with a redesigned interface based on the Component Model (Bytecode Alliance: WASI 0.2 release, January 2024).

Component Model. The WebAssembly Component Model, standardized in 2023–2024, provides a way to compose Wasm modules written in different source languages into a single application, with strongly-typed interfaces described in the WIT (Wasm Interface Type) IDL (WebAssembly Component Model repository; Component Model documentation). Two modules — one written in Rust, one in Python compiled via CPython-on-Wasm — can now interoperate across a strongly-typed language-independent interface with no glue code. The Component Model is roughly analogous to CORBA or COM but designed native to the modern web/edge/cloud stack.

Languages targeting Wasm in 2026. Nearly every mainstream language has some Wasm story: Rust (first-class), Zig (self-hosted Wasm backend), Go (both js/wasm and wasip1), TypeScript/JavaScript (via AssemblyScript or through Deno), Kotlin (Kotlin/Wasm), Swift (SwiftWasm), .NET (Blazor WebAssembly), Python (Pyodide, MicroPython/wasm), Ruby (ruby.wasm), and many more. Grain and Component-Model-native languages (Roc’s platform system, Unison’s runtime) have been designed with Wasm interoperability as a first-class assumption.

4.10 Recent developments, 2024–2026

  • Rust 2024 edition shipped in late 2024, bringing let-else stabilization tightening, the gen keyword reservation for future generator support, and expanded pattern-matching-in-let-chains (Rust 2024 edition guide).
  • Swift 6 shipped in September 2024 with strict-concurrency-by-default (opt-in), replacing data-race warnings with errors under the new mode.
  • Kotlin 2.0 (May 2024) shipped the K2 compiler as the default front-end after five years of development, a major internal replatforming.
  • TypeScript 5.5 (June 2024) added inferred type predicates, control-flow narrowing of typeof expressions, and regex-checking of literal patterns.
  • Python 3.13 (October 2024) introduced an experimental free-threaded build (PEP 703) — a version of CPython built without the Global Interpreter Lock — after Meta engineer Sam Gross’s proposal was accepted in 2023 (PEP 703 on peps.python.org). This is the first serious removal of the GIL in CPython’s history.
  • Julia 1.11 and 1.12 (2024–2025) continued to reduce first-call latency through improvements to pkgimages and native code caching.
  • Zig 0.14 (2025) further advanced the self-hosted backend and made Zig usable as a full replacement for zig cc.
  • Gleam 1.0 (March 4, 2024) — see §3.6.
  • Deno 2.0 (October 2024) reintroduced npm-compatibility as a first-class feature, marking Deno’s pivot from “Node without warts” to “Node-compatible with better defaults.”
  • Bun 1.0 (September 2023) shipped as a Zig-implemented JavaScript runtime + bundler + test runner + package manager, competing head-to-head with Node/Deno (Bun 1.0 announcement, September 2023).
  • uv (Astral, 2024) launched as a Rust-implemented Python package manager 10-100x faster than pip; by 2025 it was widely used and had expanded into a full Python project manager (uv launch, Astral, 2024; uv unified Python packaging, Astral, 2024). uv uses PubGrub (see §2.8) for its resolver.
  • Coq → Rocq rename (early 2024) — see §2.12.
  • MCP standardization (November 2024) — see §4.3.

5. Cross-Cutting Themes

5.1 Ownership, borrowing, regions, linear types — a comparison

The 2010s and 2020s have produced an unprecedented diversity of type-system approaches to memory safety without a GC. The lineage traces to Cyclone (Grossman, Morrisett, Hicks, and Cheney, 2002), a safe dialect of C developed at AT&T Research and Cornell that introduced region-based memory management and unique pointers into a mainstream C-like language — the direct ancestor of Rust’s approach (Rust borrow-checker history retrospectives).

Along a spectrum:

  • Cyclone (2002): regions, unique pointers, restricted pointers, static analysis to prevent dangling references.
  • Rust (2010–2015): affine types (Copy vs. move), borrow checking with &T / &mut T, region-inferred lifetimes, Send/Sync for concurrency.
  • Pony (2015): reference capabilities (iso, trn, ref, val, box, tag) enforcing data-race freedom in an actor model, with per-actor GC.
  • Austral (2018–): full linear types (every value used exactly once), first-class capabilities as authority tokens.
  • Vale (2019–): regions + generational references — a novel middle ground that uses small runtime checks (often elided) to catch use-after-free, avoiding both GC and borrow-check inference.
  • Hylo (2022–): mutable value semantics — every value behaves as though independently owned; sharing is expressed through projections/subscripts, giving pure-functional reasoning with in-place mutation.
  • Verus (2022–): verification of Rust code itself, proving that Rust’s ownership + user-supplied invariants imply correctness.

For a language designer building for the AI era, the design menu is genuinely rich. Rust remains the most-battle-tested; Vale and Hylo are the most novel; Austral is the most explicitly focused on capability safety.

5.2 The effect-system landscape

Effect systems, once a research topic, are now a shipping technology in multiple languages. The design lineage runs:

  • Monads and do-notation (Haskell, 1990s–) — the original mainstream approach to isolating effects in a pure language. Monad transformers layered multiple effects but scaled poorly.
  • Algebraic effects and handlers (Plotkin, Power, Pretnar; 2000s theory) — a compositional alternative to monads: effects are operations invoked by user code and interpreted by outer handlers. Implemented in Eff, Koka, Frank, Effekt, and (since 2022) OCaml 5.
  • Abilities (Unison) — Chiusano and Bjarnason’s name for algebraic effects as tracked in Unison’s type system.
  • Capabilities as effects (Pony, Austral) — an alternative approach in which effects are expressed by requiring a value (the capability) to invoke them; there is no separate effect row.
  • Uniqueness types (Clean, Rust in a limited form) — another way to track mutable/exclusive access at the type level.

For an AI-era language, the effect-system decision has become high-leverage: LLMs generate code that will interact with the world, and having a compile-time check that “this function does not do IO” or “this handler must catch this effect” turns a large class of runtime surprises into edit-time errors that the LLM can fix in the loop.

Effect systems and LLM code generation. For a language designer building for the AI era, effect systems have a subtle advantage: they turn otherwise-hidden runtime behavior into type-level signatures that an LLM can read. If a function is typed Reads[File] & Writes[Network], an LLM asked to “add error handling” can see immediately that both file and network errors are in scope. If the function is typed Pure, the LLM knows that no external error paths need to be handled. Compare with dynamically-typed languages, where the LLM must trace the whole call graph to know whether a function might do IO. The efficiency gain in reasoning is significant.

5.3 Compiler infrastructure: LLVM, MLIR, Cranelift, GCC, self-hosting

LLVM — Chris Lattner’s compiler infrastructure, born at UIUC in the early 2000s — has become the default backend for essentially every new language of the modern era. Rust, Swift, Julia, Crystal, Zig, Odin, Roc, Hylo, and Mojo all use LLVM (or emerged from LLVM); Kotlin/Native uses LLVM; Java’s HotSpot has explored LLVM through the Graal project.

MLIR (Multi-Level IR, announced by Chris Lattner in 2019) is a framework built on top of LLVM for building compilers over multiple levels of intermediate representation, from high-level tensor operations down to LLVM IR. MLIR became the technical foundation of Mojo (see §3.13) and of most modern ML-compiler stacks (IREE, Torch-MLIR, XLA/OpenXLA) (LLVM blog on MLIR history and adoption). By 2025 MLIR was arguably the most consequential compiler-infrastructure development of the decade.

Cranelift is a JIT/AOT code generator written in Rust, developed by the Bytecode Alliance. It compiles roughly two orders of magnitude faster than LLVM in exchange for slightly slower generated code — making it well-suited for wasm engines (wasmtime), for the Rust debug-build backend (rustc_codegen_cranelift), and for any use case where compilation latency matters (Bytecode Alliance and Cranelift documentation).

GCC frontends. Ada, Fortran, D, Go, Rust (via rustc_codegen_gcc), and several others target GCC in addition to (or instead of) LLVM. gccrs, an independent Rust front-end for GCC, has been in active development since 2021.

Self-hosting. Rust, Zig, Kotlin (K2), Swift, Julia, Nim, Crystal, and Idris 2 are all self-hosted or bootstrapped. The self-hosting bar has become one of the informal tests of language maturity in the modern era.

LSP + tree-sitter + LLM. A less-noticed shift is that LLM-augmented development tools now depend on the same infrastructure as human-augmented IDEs. Copilot Chat and Cursor use LSP to fetch symbol definitions and cross-references, use tree-sitter to break large files into semantically meaningful chunks, and use compiler JSON diagnostics to close the fix loop. A language that has a first-class LSP server and tree-sitter grammar is significantly more usable in agentic development environments than one that does not — which extends the tooling table stakes discussed in §5.10.

Salsa and incremental computation. Salsa (Nikko Matsakis, born in the rust-analyzer project) is a framework for incremental computation in compilers: the compiler is expressed as a set of pure functions over interned inputs, and Salsa memoizes and invalidates dependencies. Salsa powers rust-analyzer’s near-instant response times on multi-million-line codebases. The pattern (“query-based compiler”) has been imitated by newer language servers and by the K2 Kotlin compiler. A language whose compiler front-end is architected as a query graph has a structural advantage in IDE-latency-driven development.

5.4 WebAssembly as a compilation target

See §4.9 for details. The macro-story is that Wasm has become the portable execution target that the JVM promised to be in the late 1990s but never quite delivered outside enterprise Java. Wasm is smaller, more security-oriented, language-agnostic by design (rather than by afterthought), and — with the Component Model — has a language-independent type system for interoperation.

Sandboxing by construction. A key design property of Wasm that differs from the JVM: Wasm modules have no ambient authority. A module cannot open a file, make a network request, or read the system clock unless the host explicitly imports those functions into the module’s environment. This is object-capability security enforced at the runtime boundary. For an AI-era language designer, this is significant: a program compiled to Wasm and run in a Wasm engine with a carefully-limited set of host imports cannot silently perform IO, cannot exfiltrate data, and cannot mount most classes of supply-chain attacks. The trust model shifts from “trust the code” to “trust the imports.”

Component Model implications. The Component Model’s WIT interface language is a strongly-typed IDL that supports records, variants, resources (opaque handles), and asynchronous streams. Two components written in different source languages can interoperate through WIT interfaces without shared FFI conventions — the WIT canonical ABI handles the layout and lifetime conversions. This effectively makes Wasm a language-independent module system with a proper type theory behind it — a significant milestone for language-ecosystem design.

5.5 Package-manager evolution

The 2010s-2020s brought convergence around a set of practices for language package management:

  • Cargo (Rust, 2014) set the template: manifest file, lockfile, workspace, feature flags, all shipped with the language.
  • npm (Node.js, 2010) demonstrated the network effect of a single central registry — and also the risk model (left-pad, event-stream, and later slopsquatting).
  • Go modules and MVS (Russ Cox, 2018) — see §2.1 — showed that a simpler dependency resolver could still be correct.
  • PubGrub (Natalie Weizenbaum, Dart) — see §2.8 — became the algorithm of choice for Dart, Poetry, Rye, and uv.
  • Deno (Ryan Dahl, 2018) started with URL-based imports (import ... from "https://..."), abandoned it for JSR + npm compatibility in 2024 (Deno 2 announcement, October 2024).
  • Bun (Jarred Sumner, 2022) shipped a package manager that installs 10-30× faster than npm by using symlinked, globally-cached packages and native code for extraction (Bun documentation).
  • pnpm (Zoltan Kochan, 2016) pioneered the content-addressed global store with hardlinks, saving disk space and install time (pnpm motivation).
  • uv (Astral, 2024) and PDM (Frost Ming, 2019) brought modern package management to Python, both using PubGrub-family resolvers.

The consolidation of practices — manifest, lockfile, workspace, feature flags, resolver, checksum verification — is now table stakes for any new language.

5.6 Build-system convergence

Google’s Bazel (2015) and its successor Buck2 (Meta, 2022) represent one strand: language-agnostic, hermetic, remote-caching build systems that scale to monorepos of millions of files. Cargo’s workspace model represents another: per-language, opinionated, deeply integrated. Nix represents a third: language-agnostic derivations with content-addressed outputs. In practice, most modern languages ship a Cargo-style opinionated tool as default (cargo, mix, swift package, hatch, uv, bun), and Bazel/Buck2/Nix layer over that when scale demands.

5.7 Dependency resolution: PubGrub vs. MVS vs. SAT

  • SAT-based resolvers (npm’s earlier resolver, Cargo, RubyGems) treat resolution as a constraint-satisfaction problem and use backtracking. They can be slow on large constraint graphs and produce hard-to-read error messages when constraints are unsatisfiable.
  • PubGrub (Dart) improves on SAT-style backtracking by tracking incompatibilities — human-readable statements about pairs of package/version constraints that cannot both be satisfied. When resolution fails, PubGrub emits a small essay explaining why (PubGrub explainer by Natalie Weizenbaum).
  • MVS (Go) sidesteps the problem entirely by picking the minimum version that satisfies each requirement, giving up on getting the latest compatible version in exchange for a linear algorithm and reproducible builds without a lockfile (Russ Cox, “Minimal Version Selection”).

The three approaches represent genuinely different design philosophies; MVS’s simplicity has become admired even by non-Go communities.

5.8 LSP and tree-sitter

Language Server Protocol (LSP), published by Microsoft in 2016, standardized the protocol by which an editor asks a language toolchain for completions, hover text, diagnostics, and refactorings (LSP specification). Before LSP, every editor-language pair required custom integration; after LSP, one language server serves all editors. The consequence has been that new languages can reach editor-tooling parity with mature languages within a year or two.

Tree-sitter (Max Brunsfeld, 2018–) is an incremental parsing library and grammar-generation system used for syntax highlighting, code folding, and structural navigation in modern editors. Tree-sitter grammars are declarative and share across editors; the ecosystem now covers hundreds of languages (tree-sitter documentation). Tree-sitter has become essential infrastructure for the AI era as well: it provides the concrete-syntax-tree layer over which many code-intelligence tools reason.

5.8.5 Format and lint tooling standardization

A related shift: for many modern languages, one canonical formatter (gofmt, rustfmt, zig fmt, deno fmt, mix format, black for Python, dprint) and one canonical linter (clippy for Rust, revive/golangci-lint for Go, credo for Elixir, ruff for Python) have emerged as community standard. This eliminates the “style bikeshedding” that consumed 1990s–2000s language communities and gives LLMs a stable style baseline for generated code. Ruff (Astral, 2022) is particularly notable: a Rust-implemented Python linter that runs 10–100× faster than the previous generation (flake8, pylint), it has become the default linter for most new Python projects.

5.9 Governance evolution

  • Guido van Rossum stepped down as Python’s BDFL in July 2018, citing exhaustion from the PEP 572 (walrus operator) debate (Guido’s transition-of-power email to python-committers, July 12, 2018). Python adopted PEP 8016’s Steering Council model shortly afterward.
  • Larry Wall remains the honorary head of the Perl/Raku community but has not been the day-to-day leader for years. Raku (Perl 6) was renamed from Perl 6 in 2019 and continues as a small independent language.
  • Matz (Yukihiro Matsumoto) remains the BDFL of Ruby, with Ruby 3.0 (December 2020) marking a major milestone (3× faster than Ruby 2.0, initial static type support via RBS and Steep). Ruby 3.5 (December 2025) continues incremental performance and typing work.
  • Rust Foundation (see §2.2) — a member-based independent foundation.
  • Python Software Foundation — the Python-language-neutral foundation with an elected board.
  • Node.js Foundation → OpenJS Foundation (2019 merger) — a Linux Foundation project that stewards Node.js, jQuery, Webpack, and other JS ecosystem projects.
  • Swift Governance — see §2.3 — evolved to include topic-specific steering groups.

The general pattern is a move away from single-BDFL governance to foundation-based, multi-stakeholder models — driven partly by the mismatch between BDFL bandwidth and the size of modern language ecosystems.

5.10 The “language as ecosystem” thinking

The single most important cultural shift of the 2010s-2020s in programming languages has been the recognition that a language is inseparable from its ecosystem. A modern language is not just a compiler; it is a compiler + package manager + build tool + formatter + linter + LSP server + tree-sitter grammar + book/documentation + community-review process + ecosystem of common libraries + hosted registry + CI integration.

Rust’s early insistence on shipping Cargo alongside the compiler set the pattern; Elm’s insistence on shipping an elm-format alongside elm codified it; Zig’s zig fmt, Deno’s deno fmt, and Swift’s Swift-format followed. Modern language projects budget for tooling from day one; without it a language cannot compete for adoption.

A minimum viable modern language. Composing what the successful modern languages have shipped, the minimum viable tooling for a serious new language today is:

  1. Reference compiler with stable-release cadence and semver-style promises.
  2. Language server (LSP) implementation with completion, go-to-definition, find-references, and diagnostics.
  3. Tree-sitter grammar for editor syntax highlighting and structural navigation.
  4. Canonical formatter (opinionated, no config).
  5. Canonical linter with autofix suggestions.
  6. Package manager with manifest, lockfile, workspace support, and a hosted registry.
  7. Test runner with parallel execution, coverage, and structured (JUnit-XML or LSP-integrated) output.
  8. Build system with cross-compilation support and reproducible builds.
  9. Documentation generator that publishes to a hosted site.
  10. First-class CI-integration examples (GitHub Actions, GitLab, Jenkins).
  11. Structured (JSON) compiler diagnostics for LLM/agentic tooling.
  12. WebAssembly target (increasingly required as of 2026).

The list is long and each item is expensive; this is why modern languages take longer to reach adoption than languages of prior eras. But the payoff is that a modern language, once shipping, gives its users a substantially better daily experience than a 1990s or 2000s language does.

Documentation as a design discipline. Rust’s insistence on rustdoc, doctests, and The Book set a bar that has been broadly imitated: Go has godoc.org/pkg.go.dev, Elixir has ExDoc, Swift has DocC, TypeScript has TSDoc. A language whose standard library documentation is browseable, cross-linked, versioned, searchable, and includes runnable examples is now table stakes. The best documentation systems (Rust, Julia, Elixir) let library authors write examples that are also test cases — keeping the documentation from drifting from the code.


6. Open Questions for the AI-Era Language Designer

If you are building a language for the AI era, the survey above suggests a set of open questions that the modern design conversation has not yet answered:

  1. Should the grammar be optimized for LLM incremental generation? — LL(1) or LALR(1) parseability, statement terminators over indentation, single-obvious-solution syntax.
  2. Should the type system express effects and capabilities in a form the compiler can prove to the LLM? — algebraic effects (Koka, OCaml 5), abilities (Unison), capabilities (Austral, Pony).
  3. Should the memory model be borrow-check, generational-reference, mutable-value-semantics, or capability-based? — the tradeoff space has become richer than at any prior point.
  4. Should the package manager be content-addressed? — the argument for it (Unison, Nix) has strengthened as slopsquatting has become a real attack.
  5. Should the language target the WebAssembly Component Model as a first-class output? — Grain, Roc, and Unison all suggest yes.
  6. Should compiler diagnostics be structured (JSON) as well as human-readable? — Rust’s json diagnostics format is the modern standard.
  7. What is the LSP + tree-sitter + formatter + linter + package manager story, day one? — no language reaches adoption today without all five.
  8. What is the governance model? — a single BDFL is politically fragile; a foundation is expensive to set up but robust to founder-departure.
  9. What is the relationship between the language and its verification story? — Verus for Rust, Aeneas for Rust, F* production deployments, Lean-adjacent AI proof search have all made “verify what matters” a mainstream posture.
  10. How does the language cooperate with the LLM as a peer user? — structured errors, machine-readable ASTs (tree-sitter), typed effect signatures, capability boundaries, and MCP-style tool exposure all matter.

The 2010–2026 era has expanded the design menu enormously. The AI era’s language, whoever builds it, will draw from all of it.

6.1 Practical design guidance from the survey

Synthesizing the survey into a practical checklist for a language designer building for the AI era:

Grammar and syntax.

  • Prefer LL(1) or LALR(1) parseable grammar; explicitly test with grammar-constrained decoding libraries during design.
  • Prefer statement terminators (semicolons or explicit newlines within blocks) over indentation as the primary structuring mechanism, to make incremental LLM generation stable.
  • Prefer a small, unambiguous operator-precedence table; avoid user-defined operator precedence.
  • Prefer one canonical way to spell common patterns, even at the cost of some expressive brevity.
  • Ensure that the surface syntax is deterministic on formatting: foo(1,2,3) and foo(1, 2, 3) should parse identically, and the formatter should canonicalize one.

Type system.

  • Support algebraic data types with exhaustive pattern matching; make the exhaustiveness check an error, not a warning.
  • Design an error-handling model that surfaces errors in function signatures (Result, Either, throws, error unions) rather than as ambient exceptions.
  • Consider effect signatures or capability parameters so that IO, async, and mutation are visible to both humans and LLMs at the type level.
  • Provide gradual-typing or opt-in dynamic typing only as a migration path, not as a general feature; the LLM-generated code will lean into whichever typing style is easier to satisfy.

Memory and concurrency model.

  • Choose a memory model deliberately from the modern menu: tracing GC (Go, Kotlin), refcounting-with-cycle-detection (Nim, Swift), borrow-check-with-lifetimes (Rust), generational-reference (Vale), mutable-value-semantics (Hylo), reference-capabilities (Pony), or linear-plus-capabilities (Austral).
  • If concurrency is a first-class use case, choose a concurrency model deliberately: goroutine + channels (Go), async/await + tokio-style executors (Rust, Swift), actor + mailbox (Erlang/Elixir/Pony), effect handlers (Koka, OCaml 5), or structured concurrency (Swift’s task groups, JEP 505).
  • Make data-race freedom a compile-time property if possible; the cost of runtime race-condition debugging is much higher than the cost of a moderately-annotated type system.

Package and dependency management.

  • Ship a package manager with the compiler; do not leave it to the community.
  • Choose a resolver deliberately: PubGrub (best error messages), MVS (simplest and most reproducible), or SAT-based (most flexible).
  • Support cryptographic verification of dependencies by default: content hashes in lockfiles, signed publishers via OIDC.
  • Support capability-restricted execution of dependencies (Deno’s --allow-net, Wasm sandboxing) as an opt-in defense against supply-chain attacks.
  • Consider content-addressed module identity (Unison-style) for future-proofing against name-squatting and hallucinated-package attacks.

Tooling.

  • LSP + tree-sitter + formatter + linter + docgen from day one. There is no path to adoption in 2026 without all five.
  • Structured JSON diagnostics with stable schema so that LLM agents can consume them programmatically.
  • Incremental compiler front-end (Salsa-style query graph) for sub-second LSP response times.
  • REPL or interactive-mode support for exploratory work; consider Jupyter-kernel integration for data-adjacent use cases.

Ecosystem strategy.

  • Design for a first workload: pick one production use case where your language has a clear advantage (Rust’s browser-engine components at Mozilla, Elixir’s WhatsApp-scale messaging, Julia’s numerical computing) and drive that workload to a public deliverable in the first two years.
  • Publish a canonical book, tutorial series, and comprehensive standard-library reference before general marketing.
  • Choose a governance model early: a benevolent-dictator model is fine for the first few years but plan the transition to a foundation or steering-council model before the language reaches mainstream adoption.
  • Foster a community norm of high-quality diagnostics: Elm’s essays, Rust’s colored, contextual errors, and Julia’s helpful stack traces are all cultural achievements that require sustained editorial attention, not just clever engineering.

Verification and safety story.

  • Decide up front whether the language will support a verification pipeline (Verus-for-Rust, F* production-grade, Lean-adjacent) or leave verification to external tools.
  • If safety-critical use cases are in scope, budget for a formal-semantics document from day one (Rust took a decade to get one; Austral has one from day one; Vale is investing in one).
  • Consider whether the language should be memory-safe by construction (Rust, Swift, Java, Go) or memory-unsafe with best-effort tooling (C, C++, Zig).

The list is long because the modern design conversation is deep. But the payoff of doing all of this well — in the specific direction the AI era rewards — has never been higher.


7. Detailed Timelines and Comparison Tables

7.1 Timeline of major releases, 2009–2026

A compressed timeline highlighting the release milestones that most shaped the modern era of programming languages:

  • 2009 November 10 — Go open-sourced by Google, with 1.0 following in March 2012 (Go FAQ).
  • 2010 July — Chris Lattner begins work on Swift as a personal project inside Apple (Wikipedia: Swift).
  • 2011 July 19 — JetBrains publishes the first “Hello, world!” for Kotlin (JetBrains blog, 2011).
  • 2011 October — Google announces Dart with the goal of eventually replacing JavaScript (Wikipedia: Dart).
  • 2012 March — Go 1.0 released, committing to the Go 1 compatibility promise.
  • 2012 May 25 — Elixir v0.5.0 released by José Valim (Elixir blog, May 2012).
  • 2012 October 1 — Microsoft publicly announces TypeScript with Anders Hejlsberg as chief architect (Wikipedia: TypeScript).
  • 2013 — First public releases of Julia (technically 2012); PureScript begins under Phil Freeman.
  • 2014 June — Apple announces Swift at WWDC and ships Swift 1.0 by year end.
  • 2014 September — Elixir 1.0 released.
  • 2014 November — Rust Cargo package manager announced (Cargo announcement, November 2014).
  • 2015 May 15 — Rust 1.0 released (Rust 1.0 announcement, May 2015).
  • 2015 December — Apple open-sources Swift on swift.org, establishing Swift Evolution.
  • 2016 February — Kotlin 1.0 released, committing to backward compatibility.
  • 2016 June — Microsoft publishes the initial Language Server Protocol (LSP) specification.
  • 2017 May — Google announces Kotlin as first-class for Android at I/O.
  • 2017 December — Flutter alpha released; 1.0 in December 2018.
  • 2018 May — Julia paper’s language work resulted in the eventual 1.0 in August 2018.
  • 2018 July 12 — Guido van Rossum steps down as Python BDFL after PEP 572 debate (Python-committers mailing list, July 12, 2018).
  • 2018 — Go modules and MVS launched by Russ Cox (research.swtch.com/vgo-mvs).
  • 2018 — Idris 2 project starts; Andrew Kelley develops Zig.
  • 2019 — Nim 1.0 released. Deno first release. Cranelift matures for wasm engines.
  • 2020 August — Mozilla lays off much of the Servo/Rust team, accelerating foundation plans.
  • 2020 — BuckleScript renames to ReScript, forking from upstream OCaml.
  • 2021 February 8 — Rust Foundation launches with Amazon, Google, Huawei, Microsoft, Mozilla as founding members (Rust Foundation launch; DevClass article on Rust Foundation).
  • 2021 March — Crystal 1.0 released.
  • 2021 May 4 — Lean 4 released after a five-year rewrite.
  • 2021 June — GitHub Copilot launched as a technical preview.
  • 2021 October — PICARD paper published at EMNLP, foundational for grammar-constrained decoding (arXiv:2109.05093).
  • 2022 March — Go 1.18 ships generics after a decade of debate (Go generics history).
  • 2022 July — Google announces the Carbon Language at CppNorth.
  • 2022 October — Rust for Linux merged into Linux 6.1.
  • 2022 December 16 — OCaml 5.0 released with effect handlers and multicore GC.
  • 2023 January — ChatGPT / GPT-4 begin transformative impact on code generation practice.
  • 2023 May 2 — Modular announces Mojo, targeting Python + MLIR (Modular Mojo announcement).
  • 2023 May — Dart 3 shipped with records, patterns, sealed classes.
  • 2023 May — Julia 1.9 ships package-image caching, addressing time-to-first-plot problem.
  • 2023 August — Zig 0.11 ships built-in package manager (Zig 0.11.0 release notes).
  • 2023 August — Modular closes Series B; Bun 1.0 released in September 2023.
  • 2024 January — WASI 0.2 (“Preview 2”) released by Bytecode Alliance.
  • 2024 March — The xz-utils backdoor discovered, transforming supply-chain security conversation.
  • 2024 March 4 — Gleam 1.0 released (Gleam 1.0 release notes).
  • 2024 May — Kotlin 2.0 ships with K2 compiler as default.
  • 2024 Early — Coq officially renamed to Rocq (Rocq official site).
  • 2024 September — Swift 6 ships strict-concurrency mode.
  • 2024 October — Python 3.13 experimental free-threaded (no-GIL) build (PEP 703) (PEP 703).
  • 2024 October — Deno 2.0 pivots to npm compatibility.
  • 2024 November 25 — Anthropic announces Model Context Protocol (MCP) (Anthropic MCP announcement).
  • 2024 Late — Rust 2024 edition ships (Rust 2024 edition guide).
  • 2025 March — TypeScript native port announced (compiler in Go).
  • 2025 — Slopsquatting attacks become a mainstream security concern (CSA slopsquatting report, June 2025).
  • 2025 — Zig 0.14 further advances self-hosted backend.
  • 2025 December — Ruby 3.5 released (per stated Ruby release cadence).

7.2 Memory-model comparison table

LanguageMemory modelRuntimeData-race safetyLatency profile
GoConcurrent tri-color mark-sweep tracing GCRuntime scheduler + GCNot statically enforced (runtime race detector)Sub-millisecond GC pauses since 1.5
RustOwnership + borrow-check + lifetimes; no GCMinimal runtimeEnforced via Send/Sync traitsDeterministic; no GC pauses
SwiftAutomatic Reference Counting (ARC)ARC runtimeSendable protocol (Swift 6)Deterministic but per-reference cost
Kotlin (JVM)JVM tracing GC (G1, ZGC, Shenandoah)JVMNot enforcedDepends on JVM GC
Kotlin/NativeReference counting with cycle detectionNative runtimeNot enforcedDeterministic
ElixirBEAM per-process GC (isolated heaps)BEAM VMEnforced by process isolationSub-millisecond per-process pauses
JuliaNon-moving mark-sweep tracing GCRuntimeNot enforced (Threads.@threads race hazards)Milliseconds
TypeScript / JSV8/JSCore tracing GCJS runtimeNot enforcedDepends on runtime
DartGenerational tracing GCRuntimeIsolate isolationSub-100µs (recent Dart)
ZigManual + allocator injection; no GCMinimalNot enforcedDeterministic
OCaml 5Concurrent minor+major GCRuntimeNot enforcedSub-millisecond
PonyPer-actor tracing GC (ORCA) + cross-actor refcountRuntimeEnforced by reference capabilitiesPer-actor pauses only
CrystalBoehm-Demers-Weiser conservative GCRuntimeNot enforced (fibers per-thread)Milliseconds
RocPerceus reference counting with elisionPlatform runtimeNot applicable (immutable)Deterministic
UnisonContent-addressed values; JVM-hosted RCUnison VMEnforced by abilitiesSimilar to JVM
AustralLinear types + capabilities; no GCMinimalEnforced by linear typesDeterministic
ValeRegions + generational references; no GCMinimalEnforced by regionsDeterministic with small runtime checks
HyloMutable value semantics; no GCMinimalEnforced by value semanticsDeterministic
GrainWebAssembly linear memory + reference countingWasm engineDepends on Wasm engineDeterministic
MojoMLIR-lowered; ownership + heap allocationMinimalEnforced by ownershipDeterministic

(This table is a summary of the details discussed in the sections above; every property mapped here is derived from language documentation cited inline in the corresponding sections.)

7.3 Package-manager comparison

LanguagePackage managerResolverRegistryContent-addressed?Capability restrictions
RustCargoSAT-basedcrates.ioCargo.lock has SHA hashes; content-addressed via checksumsNo language-level, per-crate feature-flag isolation
Gogo modMinimum Version Selection (MVS)Distributed via VCS; go.sum + sum.golang.orgYes (module hashes in sum database)No language-level
Node.js/JSnpm / pnpm / Bun / yarnVarious (npm now SAT; pnpm has its own)npmjs.comLockfiles carry hashes; provenance signing availableNo default; some sandboxing via Deno/Bun flags
Pythonpip / uv / Poetry / PDMpip (backtracking) / PubGrub (Poetry, uv, PDM)pypi.orgWheels checksummed; PEP 740 attestationsNo language-level
RubyBundler / RubyGemsMolinillo (SAT variant)rubygems.orgGemfile.lock checksumsNo language-level
ElixirHex / mixCustomhex.pmPackage checksumsNo language-level
DartpubPubGrub (original)pub.devPackage checksumsNo language-level
SwiftSwiftPMCustomDistributed via VCS; Apple’s Swift Package RegistryPackage.resolved has checksumsNo language-level
KotlinGradle + JVM ecosystemGradle’s resolverMaven CentralCoordinate-based, checksummedNo language-level
JuliaPkgSAT-based (Registry-based)JuliaHub + General registryManifest checksumsNo language-level
ZigBuilt-in package manager (0.11+)CustomDistributed via HTTPS + hashesYes (mandatory content hashes)No language-level
DenoNative import; JSR + npm compatCustomJSR + npmURL/hash importsYes (per-permission flags)
BunBuilt-inCustomnpm-compatibleLockfile hashesNo language-level
NixNix expressionsCustom (fixed-point)Nixpkgs + flakesYes (native content-addressing)Sandboxed builds
UnisonUnison ShareN/A (content-addressed refs)Unison ShareYes (content-addressed by hash)Enforced by abilities

7.4 Effect-system comparison

LanguageEffect mechanismEffects trackedHandler mechanismInference
HaskellMonads / MTLExplicit in monad typedo-notation + runX functionsFull inference within a monad
KokaAlgebraic effects + handlersRow of effects in every function typehandler { ... }Full row-polymorphic inference
OCaml 5Effect handlersNot tracked in types (currently)try ... with effect ...No effect inference
FrankAlgebraic effectsRow of “abilities”Adjustment operatorsRow-polymorphic
EffektAlgebraic effects with second-class capabilitiesRow of effectsHandler with capabilityPartial inference
UnisonAbilities (algebraic effects)Row of abilities in function typehandle { ... }Row-polymorphic inference
RocAbilities (platform-provided)Ability constraint per functionPlatform provides implementationStatic resolution
Rust? / Result + async traits + Send/SyncErrors and concurrency via types? propagation, executors for asyncNo effect inference (types explicit)
Swiftthrows + async + SendableErrors, async, sendabilitytry / awaitNo effect inference
GoMultiple return + context.Context propagationErrors + cancellationExplicit if err != nilNone
ZigError unions + colorless functionsErrors, allocator contextExplicit try / catchNone
AustralCapabilities as first-class valuesIO/Alloc/etc. via capability valuesPattern matching on capabilitiesNone
PonyReference capabilitiesData-race safety at capability levelCompiler-checked capability rulesFull at compile time

7.5 Comparison: parser tooling for LLM-consumption

The tools an AI-era language design must have to interoperate cleanly with LLM tooling:

LanguageTree-sitter grammarLSP serverJSON diagnosticsFormatterLinter
RustYesrust-analyzerYes (--error-format=json)rustfmtclippy
GoYesgoplsYesgofmtgo vet, staticcheck, revive, golangci-lint
SwiftYesSourceKit-LSPPartialswift-formatSwiftLint
KotlinYesKotlin LSP + IntelliJYesktfmtdetekt, ktlint
TypeScriptYestsserverYesPrettier, dprint, biomeESLint, biome
PythonYesPylance, pyright, pyright-lspYesblack, ruff formatruff, pylint, flake8, mypy
ElixirYesElixirLS, LexicalPartialmix formatcredo
JuliaYesLanguageServer.jlPartialJuliaFormatterStaticLint.jl
ZigYesZLSPartialzig fmtnone-canonical
OCamlYesocaml-lsp-serverPartialocamlformatnone-canonical
GleamYesbuilt-inYesgleam formatbuilt-in
RocYesroc language serverYesbuilt-inbuilt-in
UnisonYesUCM (custom)Custombuilt-inbuilt-in

(As of 2026, all listed languages meet the minimum viable modern language checklist in §5.10; new languages are effectively required to reach this level of tooling coverage before mainstream adoption.)

7.6 Adoption context: notable large-scale production deployments

Rust in production (as of 2026):

  • Linux kernel drivers (Rust for Linux merged in 6.1, 2022)
  • AWS Firecracker microVM (production since Lambda’s early days)
  • Microsoft Windows kernel components (announced 2023–2024)
  • Discord: performance-critical services
  • Cloudflare: pingora HTTP proxy replacing nginx
  • Figma: multiplayer server and CRDT engine
  • Dropbox: internal storage system Magic Pocket components
  • Ferrocene: Ferrous Systems’ qualified compiler for safety-critical (automotive/aerospace) use
  • Compiler tooling: ruff (Python), biome (JS), uv (Python), turbopack (Vercel), swc (JS), esbuild-like reimplementations across ecosystems

Go in production (as of 2026):

  • Kubernetes and the entire CNCF cloud-native stack (Docker, Terraform, Prometheus, etcd, Helm, Envoy control plane, Consul)
  • Cloudflare: large parts of the edge software
  • Uber: microservice fleet
  • Twitch: chat infrastructure
  • Netflix: various backend services
  • Dropbox: some services migrated from Python
  • Google’s own internal SRE and infrastructure tooling

Swift in production (as of 2026):

  • Apple platform apps (iOS, macOS, iPadOS, watchOS, tvOS, visionOS) — Swift-first
  • Airbnb, LinkedIn, Uber mobile apps
  • Apple’s iCloud infrastructure via SwiftNIO on the server side
  • Some Google apps (photo processing, some server components)

Kotlin in production (as of 2026):

  • Android app development — Kotlin-first policy since 2019
  • Netflix, Uber, JetBrains, Amazon (some), Meta (some) server backends
  • Compose Multiplatform gaining desktop and iOS traction 2024–2025

Elixir in production (as of 2026):

  • Discord’s WebSocket infrastructure (billions of concurrent messages)
  • Pinterest’s notification pipeline
  • Toyota Connected vehicle backend
  • Change.org, Bleacher Report, and many high-uptime web services
  • Broadway data-processing pipelines

Julia in production (as of 2026):

  • Climate Modeling Alliance (CliMA) at Caltech/MIT for climate simulations
  • Pumas AI for pharmacometric modeling in drug development
  • FAA aircraft-simulation verification
  • Aviva, Moderna, Pfizer (specific applications)

TypeScript in production (as of 2026):

  • VS Code, GitHub, Slack, Notion, Figma, Linear (front-end)
  • Bloomberg terminal (large enterprise TypeScript)
  • Meta WhatsApp Web (TypeScript codebase)
  • Airbnb, Stripe, LinkedIn (mixed but TypeScript-heavy)
  • Deno CLI itself; Bun’s tooling

F* in production (as of 2026):

  • HACL* verified cryptographic library used by Mozilla NSS, Linux kernel WireGuard, Python cryptography library (HACL* GitHub)
  • miTLS verified TLS implementation
  • Microsoft Windows kernel components via EverParse (Project Everest)

Lean in production (as of 2026):

  • mathlib (≫1M lines of formalized mathematics; used at Cambridge, ETH, Stanford, Princeton, MIT)
  • AWS: internal use of Lean for some verification workloads
  • Multiple mathematics research programs (Terence Tao’s PFR conjecture, 2023; DeepMind’s AlphaProof, 2024)

Zig in production (as of 2026):

  • Bun runtime (JavaScript/TypeScript) — largest known Zig deployment
  • TigerBeetle database
  • Ghostty terminal emulator
  • Some hobbyist embedded projects and demoscene use

Dart/Flutter in production (as of 2026):

  • BMW, Toyota, Alibaba, ByteDance mobile apps
  • Google Pay, Google Ads mobile clients
  • Many crypto exchange mobile apps
  • Emerging cross-platform desktop apps

Elm in production (as of 2026):

  • Vendr, NoRedInk, Culture Amp (front-end)
  • Small but stable production user base

7.7 Language-designer voices and canonical writings

Selected canonical writings that shaped the modern design conversation:

  • Rob Pike, “Concurrency is not parallelism” (2012) and “How Go was made” (2015) — defined the Go design ethos.
  • Russ Cox, “Minimal Version Selection” (2018) and “Our Software Dependency Problem” (2019) — shaped the modern discussion of package management.
  • Graydon Hoare, various posts on Rust history and design lineage — documented Rust’s pre-1.0 evolution.
  • Niko Matsakis, extensive blog posts on Rust borrow checking, NLL, Polonius, async, and the Rust roadmap.
  • Aaron Turon, “Fearless Concurrency” and other early Rust design articles.
  • Bryan Cantrill, various talks on operating systems, Rust adoption, and Zig comparisons.
  • Anders Hejlsberg, “TypeScript design principles” (early TypeScript talks) and the 2025 announcement of the Go-based native compiler port.
  • Simon Peyton Jones (SPJ), papers on Haskell type inference, algebraic effects, and (more recently) Verse language design.
  • Chris Lattner, papers and talks on LLVM, Swift, MLIR, and Mojo.
  • José Valim, various Elixir keynote talks and the ongoing Elixir-types-project posts.
  • Guy Steele Jr., “Growing a Language” (1998) and continued papers on language design.
  • Andreas Rossberg, work on WebAssembly’s design and formalization.
  • Rich Hickey, various “Simple Made Easy” – style talks on Clojure and language design generally.
  • Evan Czaplicki, Elm essays on error messages and language design constraints.
  • Kenton Varda, articles on Cap’n Proto, CapTP, and object capabilities.
  • Andrew Kelley, various posts and talks on Zig’s design decisions.
  • Rich Feldman, various talks on Roc’s design and the Elm-derived design language.
  • Nadia Eghbal, “Working in Public” (2020) — the definitive contemporary analysis of open-source maintainer sustainability.

8. Case Studies: Five Design Decisions That Shaped the Era

This section extracts five design decisions from the survey that had disproportionate downstream impact, and analyzes each in terms that a language designer building for the AI era can act on.

8.1 Case study: Cargo’s Cargo.toml and lockfile model

The decision. Rust shipped Cargo alongside the 1.0 compiler in May 2015 with three interlocked ideas: (1) a human-editable manifest file, Cargo.toml, at the root of every crate that declares dependencies, features, and metadata; (2) a machine-generated lockfile, Cargo.lock, that pins the exact resolved versions of transitive dependencies; and (3) a canonical hosted registry, crates.io, that all Rust developers publish to and depend on by default (Cargo announcement; Cargo documentation).

Why it mattered. Before Cargo, systems languages (C, C++) had no canonical package manager — CMake, Autotools, apt, Homebrew, vcpkg, and Conan all competed and mostly failed to give C++ developers a single source of truth. Cargo demonstrated that a language could ship a package manager from day one that was simultaneously easy for beginners (a single command, cargo build), reproducible for CI systems (lockfile pinning), and expressive enough for large workspaces (multi-crate layouts, feature flags, workspace inheritance).

Downstream imitators. SwiftPM (2015, Package.swift), Deno’s deno.json (2018–2024 evolution), Bun’s bun.lockb, Astral’s uv (2024), Julia’s Project.toml/Manifest.toml, Zig’s build.zig.zon package manager (2023), and countless in-house tools all follow the manifest+lockfile+registry pattern that Cargo established.

AI-era implications. For LLM-generated code, a canonical package manager is essential: the LLM must produce output that the developer can build with a single command, without needing to describe or reproduce a bespoke build setup. Languages without a canonical package manager (C++, older Fortran) generate LLM outputs that require significantly more human intervention to build than Cargo-family languages do. The design lesson is: ship the package manager.

8.2 Case study: Go’s Minimum Version Selection

The decision. Russ Cox designed Minimum Version Selection (MVS) for Go modules in 2018 as a deliberately simple alternative to SAT-based dependency resolution. Given a set of module requirements (e.g., “A requires B v1.2 or higher; C also requires B v1.5 or higher”), MVS picks the minimum version of B that satisfies all requirements (in this case, v1.5) — not the latest available version (Russ Cox, “Minimal Version Selection”; Go modules reference).

Why it mattered. SAT-based resolvers (npm, Cargo) always prefer the latest compatible version, meaning that a build’s result depends on when it was run: a new release of any transitive dependency can silently change the build. MVS eliminates this class of temporal nondeterminism at the cost of not automatically picking up latest patches. Combined with go.sum (checksums for every module version the build has ever used) and sum.golang.org (a transparency log for module hashes), MVS gives Go supply-chain properties that most package ecosystems still lack in 2026.

Downstream imitators. MVS’s simplicity has been widely admired but only sparsely imitated (few languages have gone all-in on MVS). Go’s sum.golang.org model has, however, influenced npm provenance signing, PEP 740 attestations, and Cargo’s trusted-publishers work.

AI-era implications. In an LLM-authored codebase, deterministic and reproducible builds are especially valuable — the LLM should not be surprised by version drift between edit-time and CI-time. MVS’s minimum-version discipline plus checksum databases give the LLM (and the human reviewer) a strong invariant to reason about. The design lesson is: prefer reproducibility over latest-version convenience.

8.3 Case study: Rust’s borrow checker and Non-Lexical Lifetimes

The decision. Rust’s borrow checker enforces that a value has either any number of shared references or exactly one mutable reference at any point in the program — the aliasing XOR mutability rule. Non-Lexical Lifetimes (NLL, 2018) refined the check from scope-based reasoning to control-flow-graph reasoning, dramatically reducing false positives (Rust NLL announcement, 2018; Rust borrow checker retrospectives).

Why it mattered. Aliasing XOR mutability is a strong invariant that prevents whole classes of concurrency bugs (data races) and use-after-free bugs at compile time, without runtime cost. The subsequent decade has seen extensive research on formalizing the invariant (RustBelt, Aeneas’s translation, Place Capability Graphs), tightening the borrow checker (Polonius, NLL, GATs), and verifying user code against it (Verus, Prusti, Creusot, Kani).

Downstream imitators and design alternatives. The borrow checker’s cost (learning curve, compilation time, occasional false positives) has motivated a range of alternative memory-safety models:

  • Generational references (Vale): a small runtime check catches use-after-free, avoiding both GC and the borrow checker’s rigidity.
  • Mutable value semantics (Hylo): every value is uniquely owned; sharing goes through projections and subscripts.
  • Reference capabilities (Pony): compile-time capabilities enforce data-race freedom in an actor model, with per-actor GC.
  • Linear types with capabilities (Austral): every value must be used exactly once, with capabilities gating side effects.
  • Content-addressed immutable values (Unison): every value is an immutable hash; aliasing is safe by construction.

Each represents a distinct point in the memory-safety-without-GC design space.

AI-era implications. LLMs generate code whose lifetime and aliasing semantics are difficult to reason about without a strong type system. A memory-safety-checking compiler catches whole classes of bugs at edit-time that would otherwise become runtime failures the LLM has to iterate to fix. But the choice of which memory-safety mechanism is up for grabs: borrow-check is the most mature, but generational references and mutable value semantics may be easier for LLMs (and humans) to produce correct code in. The design lesson is: pick a memory-safety mechanism deliberately, and understand its LLM-generation profile.

8.4 Case study: TypeScript’s structural, gradual, erased type system

The decision. TypeScript’s type system is (1) structural — two types are compatible if they have compatible members, without any nominal declaration; (2) gradual — the any type opts out of type checking, and unknown is the type-safe unknown; (3) erased — the compiler strips all type annotations to produce clean JavaScript (TypeScript handbook; Wikipedia: TypeScript).

Why it mattered. These three properties together made TypeScript adoptable at scale: existing JavaScript codebases could be migrated file-by-file (gradual), library types could be added post-hoc via .d.ts files (structural), and there was no runtime cost or compatibility break (erased). No prior gradual-typing effort (Sorbet, Hack, Flow) achieved TypeScript’s adoption curve. TypeScript is arguably the most successful new type system deployed in the modern era.

Downstream imitators. Python’s PEP 484 type hints (structural via Protocol, gradual via Any, erased at runtime except by static checkers) directly imitate TypeScript’s model. Sorbet (Ruby, Stripe) and Hack (PHP, Facebook) follow the same pattern. Every subsequent effort to add types to a dynamic language has been shaped by TypeScript’s design template.

AI-era implications. LLMs benefit disproportionately from type systems: types provide the compiler-checked structure that LLMs can lean on rather than guessing. Structural typing is particularly LLM-friendly because it does not require the LLM to know or invent nominal type declarations — any object with the right shape works. The design lesson is: if adding types to a dynamic language, favor a structural, gradual, erased design over a nominal or runtime-enforced one.

8.5 Case study: MCP as a language-independent tool interface

The decision. Anthropic’s Model Context Protocol (MCP, November 2024) defines a JSON-RPC protocol by which a language model client can discover the tools, resources, and prompts offered by an MCP server. Tools are described by JSON Schema and can be implemented in any language — Python, TypeScript, Rust, Go, Swift, C# — as long as the server speaks the MCP protocol over stdio or HTTP (Anthropic MCP announcement; MCP introduction docs).

Why it mattered. MCP effectively became a language-independent type system for LLM tool calls within one year of its announcement. The LLM has become the lingua franca between language ecosystems: two programs no longer need to speak the same source language, only the same tool schema. This is a subtle but consequential shift: the choice of implementation language for an MCP server is now a secondary concern, driven by developer preference and library availability, rather than by interoperability constraints.

Downstream imitators. Google’s A2A (Agent-to-Agent) protocol (2025) and OpenAI’s function-calling extensions borrow from MCP’s design vocabulary. IDE clients (Cursor, Zed, Windsurf, VS Code Copilot Chat) have implemented MCP clients through 2025.

AI-era implications. For a language designer, MCP suggests that language-native interoperability may matter less than tool-schema interoperability: a language whose functions can trivially be exposed as MCP tools — with self-describing JSON Schemas, capability-typed side effects, and safe execution boundaries — is well-positioned for the agentic development era. The design lesson is: design for MCP-first (or its successors) interop, not just for the language’s native FFI.


9. Reflections and Meta-Themes

9.1 The two-decade tightening of the language–tooling coupling

One of the clearest themes across the modern era is that a language and its tooling have become inseparable. In the 2000s, a language could ship as “just a compiler” (Perl, older Ruby, older Python) and let the community assemble the rest. In the 2010s–2020s, this became impossible: the developers a new language must attract have grown up on Rust’s Cargo, Go’s toolchain, and TypeScript’s IDE integration, and will not adopt a language that lacks their equivalents.

The practical consequence is that a modern language is a much larger engineering project than a 1990s or 2000s language was. Rust’s team is dozens of people; Swift’s team at Apple is hundreds. Go, Kotlin, and Julia each have full-time paid teams. Even “small” languages like Elixir, Zig, and Gleam absorb multiple full-time equivalents in tooling work alone. The days of one designer with a compiler are largely over for languages that aspire to production adoption.

9.2 The verification-as-a-service moment

By 2025 the verification community had reached a milestone that would have been unthinkable in 2010: production deployments of formally-verified code at large scale (HACL* in Firefox, Linux, and Python; Amazon’s use of Dafny; Microsoft’s use of F* and Verus; the mathlib formalization of state-of-the-art mathematics). AI-assisted proof search (AlphaProof, Copilot-for-Lean) has begun to lower the human cost of formal verification. It is plausible that by 2030 verified libraries for widely-used domains (cryptography, parsers, database engines, kernel drivers) will be common enough that using unverified alternatives feels irresponsible for security-critical work.

The language-design implication is that verification-friendly features (effect signatures, ownership systems, pre/post/invariant DSLs, decidable subsets) may matter more than they did a decade ago — and that a language which cannot participate in the verification story may be at a growing structural disadvantage for high-stakes production use.

9.3 The Wasm inflection point

WebAssembly has moved from a browser bytecode (2017) to a cross-language module system with strong sandboxing (2024–2025). The Component Model gives Wasm a proper type theory for cross-language interoperation; WASI gives it a portable OS interface; the sandboxed execution model gives it capability-safe execution by construction.

By 2026 nearly every major language has a Wasm compilation story. The next question is whether a first-class Wasm language emerges — one designed from the start around WIT interfaces, capability-safe imports, and sub-second cold-start times — or whether existing languages (Rust, Go, TypeScript, Swift) crowd the niche. Grain, Roc, and Unison are all in some sense first-class Wasm languages already; their small-but-committed adoption suggests the design space is open.

9.4 The AI turn is early

The most consequential development of 2023–2026 has been the mainstreaming of LLM-generated code. The design conversation has only begun to catch up. Grammar-constrained decoding, effect signatures readable by LLMs, capability-typed imports, content-addressed modules, machine-readable diagnostics, and MCP-style tool interop are all early responses to the new reality.

A reasonable expectation for the second half of the 2020s is that the design center of new languages shifts further toward machine-verifiable structure that gives both humans and LLMs strong guarantees. The languages that succeed will not be the ones that maximally express human aesthetic preferences (as often drove design in prior eras) but the ones that maximally enable automatic verification and repair by both humans and LLMs working together.

9.5 The design menu has never been richer

The survey above has covered dozens of languages, each exploring a distinct point in the design space. Ownership × effects × capabilities × concurrency × memory model × packaging × governance × verification × tooling produces a combinatorial space far larger than any prior era. Rather than converging on a single “best” design, the modern era has expanded the range of viable designs.

For a language designer building for the AI era, the practical implication is that the space of good answers is broad and the terrain is well-mapped. What is scarce is not design ideas but the sustained execution to ship a language + tooling + ecosystem to production. The successful modern language projects (Rust, Go, Swift, Kotlin, TypeScript, Elixir, Julia, Gleam) have all combined interesting design decisions with multi-year, well-funded, well-staffed execution. That is now the recipe.


Selected References (subset; every specific claim in this report is inline-linked above)

Primary sources used include the official documentation, blogs, and language references cited inline throughout. Notable landmark papers, talks, and posts cited above:

n.a. — Where specific version numbers or dates for 2025-2026 releases could not be verified from a primary source they are marked “n.a.” in-text, or referenced through the closest verifiable primary source with the caveat noted.