Timeline

Lines of influence

30 moments across seven languages, oldest to newest. Filter by language, or follow the threads of influence below.

1987 · OCaml — Caml — the ML descendant
OCaml's lineage traces to Robin Milner's **ML** (1973) for the LCF theorem prover. In 1985 Guy Cousineau and colleagues at INRIA designed **Caml** atop the Categorical Abstract Machine; the first **Caml** implementation appeared in **1987**.1987 · Perl — Perl 1.0 released
Larry Wall — a linguist by training — released **Perl 1.0** to the `comp.sources.misc` Usenet newsgroup on **18 December 1987**. Built to make practical extraction and reporting feel effortless, it fused `awk`, `sed`, the shell, and `C` into one text-slinging glue language.1991 · Perl — Perl 4 & the Camel Book
**Perl 4** (1991) was the version documented by the first edition of O'Reilly's *Programming Perl* — the famous **"Camel Book"** — which is why a dromedary became the language's mascot. It was a stabilization release rather than a redesign.1991 · Python — Python 0.9.0 released
Guido van Rossum, having started the project over Christmas 1989 as a hobby, released **Python 0.9.0** to `alt.sources` in **February 1991**. It already had exceptions, functions, and the core types `list`, `dict`, and `str`. The name was a nod to *Monty Python's Flying Circus*.1994 · Perl — Perl 5.000 — references & modules
**Perl 5.000** shipped on **17 October 1994** as a near-total rewrite. It introduced *references*, real *data structures*, lexically-scoped `my` variables, *packages* and *modules*, and a blessed-reference object system, making the language extensible for the first time.1995 · Perl — CPAN goes live
On **26 October 1995** the **Comprehensive Perl Archive Network (CPAN)** went live — the first large-scale open-source package archive and the spiritual ancestor of npm, RubyGems, PyPI, and Cargo.1996 · OCaml — Objective Caml (OCaml)
Modern **OCaml** emerged in **1996** when Didier Rémy and Jérôme Vouillon added an elegant object system to Caml Special Light — itself the bearer of a native-code compiler and a powerful module system. The result was *Objective Caml*: functional, imperative, and object-oriented in one.2000 · Raku — Perl 6 announced
At the Perl Conference in **July 2000**, Larry Wall announced **Perl 6** — a community-designed, backward-incompatible redesign answering hundreds of RFCs. Wall framed it as a *sister language* to Perl, not a replacement, working through the requests in his famous *Apocalypses*.2000 · Python — Python 2.0
**Python 2.0** arrived in **October 2000**, adding list comprehensions, a cycle-detecting garbage collector, and Unicode support. It was developed in a more open, community-driven process than earlier versions.2005 · Raku — Pugs proves the design
Audrey Tang's **Pugs**, a Haskell-based Perl 6 interpreter started in **2005**, was the first implementation to run real Perl 6 code. It pulled functional-programming sensibilities — lazy lists, immutability, strong typing — deeper into the language while the design was still settling.2006 · Rust — Rust begins as a side project
**Rust** started in **2006** as a personal project of Mozilla engineer **Graydon Hoare**, aiming for memory safety without a garbage collector. Mozilla began officially sponsoring it in **2009**, drawing affixed and substructural ideas from the ML family and Cyclone.2008 · Python — Python 3.0 — the great break
**Python 3.0** shipped in **December 2008**: a deliberately backward-incompatible cleanup that made `print` a function, unified `str` on Unicode, and fixed long-standing warts. The 2-to-3 migration would dominate the community for over a decade.2009 · Go — Go announced
Conceived at Google in September 2007 by **Robert Griesemer, Rob Pike, and Ken Thompson** as an antidote to slow builds and tangled dependencies, **Go** was announced publicly on **10 November 2009** and open-sourced. Its mascot, the Gopher, arrived with it.2012 · Go — Go 1.0 — the compatibility promise
**Go 1.0** shipped on **28 March 2012**, freezing the language and standard library with a famous *compatibility guarantee*: code written for Go 1 would keep compiling for the life of the Go 1 line.2012 · OCaml — OCaml 4.00 — GADTs
**OCaml 4.00** (2012) added **Generalised Algebraic Data Types (GADTs)** and first-class modules, sharply increasing the expressive power of the type system. The version-numbering scheme also switched to the now-familiar `4.xx`.2015 · Rust — Rust 1.0
**Rust 1.0** was released on **15 May 2015**, stabilizing the **ownership and borrow-checker** model — affine types enforcing memory and data-race safety at compile time with zero runtime cost.2015 · Python — async/await & type hints (3.5)
**Python 3.5** (13 September 2015) added native coroutines via `async def`/`await` (PEP 492) and the `typing` module for optional type hints (PEP 484), reshaping how large Python codebases are written and checked.2015 · Raku — 6.c "Christmas" release
On **Christmas Day, 25 December 2015**, the **6.c "Christmas"** release delivered the first official, versioned language specification with a conforming **Rakudo** implementation on **MoarVM**. This is the date Raku is generally said to have "appeared."2018 · Rust — Rust 2018 edition
The **2018 edition** (Rust 1.31, December 2018) introduced the *edition* mechanism for opt-in, non-breaking language evolution, along with a cleaner module path system and non-lexical lifetimes (NLL) that made the borrow checker far more ergonomic.2019 · Go — Go modules become default
After years of `GOPATH` friction, **Go modules** — versioned dependency management with a minimal-version-selection algorithm — became the default in **Go 1.13 (August 2019)**, finally giving the ecosystem reproducible builds outside a single workspace.2019 · Raku — Perl 6 renamed Raku
In **October 2019**, Larry Wall approved renaming **Perl 6 to Raku** — ending years of brand confusion with its sister language. "Raku" nods to the **Rakudo** compiler and means roughly "comfort" or "ease" in Japanese; `use v6` stays valid.2019 · Rust — async/await stabilized
**Rust 1.39** (7 November 2019) stabilized `async`/`await` syntax, building zero-cost futures on the ownership model and unlocking high-performance asynchronous I/O ecosystems like Tokio.2020 · Python — Python 2 sunset
On **1 January 2020**, after 20 years, **Python 2.7 reached end of life**. By then Python 3.8 (Oct 2019) had brought the controversial walrus operator `:=`, and Guido van Rossum had stepped down as BDFL in favor of a Steering Council.2021 · Rust — Rust Foundation & 2021 edition
In **February 2021** the independent **Rust Foundation** was formed (with AWS, Google, Microsoft, Mozilla, and Huawei) to steward the language, followed by the **2021 edition** (Rust 1.56) in October. Rust has since become the first non-C language adopted into the Linux kernel.2022 · Go — Generics arrive (Go 1.18)
**Go 1.18** (15 March 2022) added **type parameters (generics)** with constraints and a `comparable` interface — the most significant language change since Go 1.0, and the most-requested feature for a decade.2022 · OCaml — OCaml 5.0 — multicore & effects
**OCaml 5.0.0** (December 2022) was a complete rewrite of the runtime: it removed the global GC lock for true **multicore parallelism** and introduced **effect handlers** via delimited continuations, enabling structured concurrency with no syntactic `async`/`await` coloring.2023 · Perl — Corinna object system (5.38)
A built-in, declarative object system — codenamed **Corinna** — landed experimentally in **Perl 5.38 (2023)** with `class`, `field`, `method`, and `ADJUST`, refined in **5.40 (June 2024)** with field accessor attributes like `:reader`. The stable line sits in the 5.40 / 5.42 range as of 2026.2026 · guji — guji quest initiated
**guji** is an in-house language born in **2026**: a compiled, statically-typed, *functional-first* language that compiles ahead-of-time to a single self-contained native executable. Quest `QST-0000021` was initiated on **8 June 2026**, with the **v0 specification** as the single source of truth. Its guiding principle is *"one obvious way"* — exactly one idiomatic construct per task.2026 · guji — v0 spec — text is first-class
The v0 spec makes **text a first-class concern**: regular-expression literals and **PEG grammars** are part of the language, not a library — guji's signature capability. Bindings are immutable by default with inferred static types, and emoji are valid in `snake_case` identifiers behind sigils (`$🚀`, `@🎯`, `%🗺`).2026 · guji — Tree-walking evaluator & REPL
The first deliverable — a **tree-walking evaluator with a REPL** — runs real guji programs. Confirmed locally: `@nums.filter({ $_ % 2 == 0 }).map({ $_ * 2 }).sum()` evaluates correctly, and a `grammar Email { rule TOP { <user> '@' <domain> } ... }` parses `ada@example.com` into named captures accessed with `$b<user>`.

Influence

Perl redesigned as RakuPerl informed the scripting style of PythonPerl lent text/regex pragmatism to GoPython inspired the readability ethos of GoPython contributed ideas to RakuOCaml shaped the type system of RustOCaml lent functional ideas to RakuOCaml modeled functional-first design for gujiRust informed single-binary compilation of gujiRaku inspired first-class grammars in gujiPerl shaped first-class regex of gujiGo modeled self-contained native output for guji