PL history: 2010 through September 2026

17 Sep 2026. This page is the 13 Sep synthesis of an external research run. The Mo it describes — brace syntax, effect rows, a Rust implementation, a package registry, an RFC process — was never Mo’s design. Mo’s decisions are the spec chapters under spec/design-v0/ and the decision-log. Read this page as landscape only.

Headline

Sixteen years in which language design collapsed the false trade-offs of the 1990s. Memory safety without a GC (Rust). Type inference without dynamism (Julia, TypeScript). Package managers bundled from day one (Cargo). Then the AI turn (2023+) rewrote who the language is for.

Three findings that shape everything

  • Cargo (2014) is the design template. A first-class package manager with a lockfile, SemVer resolution, workspaces, and features — shipped with Rust from 1.0. Every language since has copied it or paid the price for not doing so.
  • MVS (Russ Cox, 2018) is the sane alternative to SAT resolvers. Go modules pick the minimum version satisfying all constraints. Reproducibility by construction; no lock file needed for correctness. Slower to get new features, but no surprise builds.
  • The AI turn (2023–2026) makes an LLM the principal user of the language. Grammar-constrained decoding (PICARD, Outlines, XGrammar), Model Context Protocol (Anthropic, Nov 2024), and slopsquatting attacks reshape what the language must optimize for. See d01-agents-write-the-code.

Era 7: The 2010s — systems renaissance & type-system maturity

Systems languages.

  • Go (Griesemer/Pike/Thompson, 2009, 1.0 in 2012) — deliberate simplicity, goroutines/channels, gofmt culture, and eventually MVS. See go-history.
  • Rust (Hoare + Mozilla, 1.0 May 2015) — ownership + borrow checking + traits + Cargo. See rust.

Modern JVM/ecosystem languages.

  • Kotlin (JetBrains, 2011; Android first-class 2017) — practical Java replacement.
  • Swift (Lattner + Apple, 2014; open-sourced 2015) — the Objective-C successor.
  • Elixir (Valim, 2011) — Ruby-flavored Erlang on BEAM. See elixir.
  • Julia (Bezanson et al., MIT; 1.0 2018) — dynamic-typed with type inference; scientific computing.

Web/JS ecosystem.

  • TypeScript (Hejlsberg + Microsoft, October 2012) — gradual types on top of JS. Won the industry.
  • Dart + Flutter (Google, 2011 / Flutter era 2018+) — mobile cross-platform.
  • Elm (Czaplicki, 2012) — pure functional web; friendly errors.

Dependent types go practical.

  • Idris 2 (Brady, ECOOP 2021) — Quantitative Type Theory (linear + dependent).
  • Lean 4 (de Moura, 2021; mathlib community) — proof assistant and functional PL. See dependent-types.
  • Rocq (formerly Coq, renamed 2024).

Era 8: Late 2010s–early 2020s — verification, effects, capabilities

  • Zig (Kelley, 2016+) — “more pragmatic than C.” See zig.
  • Koka (Leijen, Microsoft Research) — algebraic effects with evidence-passing translation.
  • OCaml 5.0 (December 2022) — first mainstream shipping language with effect handlers as a runtime feature.
  • Unison (Chiusano, Bjarnason) — content-addressed code; every function has a hash-based name. Ancestry: Nix derivations. See unison.
  • Roc (Feldman, 2019+) — pure functional; Elm-inspired; capability-aware effects. See roc.
  • Gleam (Pilfold, 2016+, 1.0 March 2024) — statically typed BEAM language.
  • Austral (Borretti, 2018+) — linear types + capabilities + no null. Explicit inspiration for Mo. See austral.
  • Vale (Ovadia, 2019+) — generational references for memory safety without GC or borrow checker.
  • Hylo (formerly Val; Racordon, 2022+) — mutable value semantics; subscripts and parts. See hylo.
  • Carbon (Google, 2022+) — a C++ successor for organizations that cannot leave the ecosystem.
  • Mojo (Modular / Lattner, 2023+) — Python-superset for AI/ML kernels; MLIR-first.

Era 9: The AI era, 2023–2026

  • Grammar-constrained decoding. PICARD (EMNLP 2021), Outlines (2023), XGrammar (2024), Guidance, SynCode. LLMs can now be forced to emit syntactically valid programs in any CFG.
  • Copilot (2021) → Cursor (2023) → agentic coding (2024+). By 2026 a large fraction of production code is agent-generated.
  • Model Context Protocol (Anthropic, November 2024) — standardizes how LLMs discover and invoke tools.
  • Slopsquatting — attackers register packages LLMs hallucinate. See Cloud Security Alliance report. Direct motivation for d30-supply-chain-security.
  • Verification renaissance. Prusti, Verus, Creusot, Aeneas, Flowistry all put Rust-adjacent verification within reach of production engineers.
  • Effect systems in production. OCaml 5, Unison, Roc, Koka — algebraic effects with handlers.
  • Capability revival. Austral, Monte, Object-Capability lineage all resurfacing.
  • Content-addressed code. Unison, plus Nix derivations, plus emerging build-cache designs.
  • WebAssembly maturation. WASI Preview 2 (2024), component model landing, WebAssembly as a portable systems target.

Cross-cutting themes

  • Compiler infrastructure. LLVM, MLIR, Cranelift, GCC — every new language starts by picking one.
  • Package-manager evolution. Cargo → npm’s ecosystem gravity → PubGrub (Dart, uv) vs. MVS (Go) vs. SAT (npm, Cargo).
  • LSP + tree-sitter. Editor integration ships within months, not years, for any new language.
  • Format + lint tooling standardization. gofmt → rustfmt → zig fmt → deno fmt. Style rules become laws.

What Mo takes

What Mo refuses

  • npm-style trust defaults. Post-install scripts, unrestricted transitive install, no capability declarations.
  • Rust’s macro complexity. Procedural macros are agent-hostile.
  • The lazy/pure Haskell substrate. Strict evaluation only.
  • Class-based OO as the organizing principle. d06-never-oop remains.

Sources