Timeline

Lines of influence

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

1967 · C - BCPL - the typeless ancestor
**Martin Richards** designs **BCPL** (Basic Combined Programming Language), a typeless, word-oriented systems language descended from ALGOL 60. BCPL is the root of the line that runs through **B** to **C**: it establishes the lean, close-to-the-machine style - curly-brace-style blocks, a tiny core, and a compiler small enough to bootstrap onto minicomputers - that C would inherit and refine.1969 · C - B - C's immediate predecessor
**Ken Thompson** creates **B** at Bell Labs (1969-70), a stripped-down, typeless descendant of BCPL small enough to fit the memory of the era's minicomputers. B was word-oriented and had no data types; as Unix moved to the byte-addressed PDP-11, its limitations pushed Dennis Ritchie to add types and a richer syntax - first as "New B," then as C.1970 · Forth - Forth is born
**Charles H. "Chuck" Moore** first uses **Forth** in 1970, growing it out of a personal programming system he had developed since 1968. Forth is a stack-oriented, extensible language and interactive environment in which the programmer defines new "words" that compile down to threaded code. It was first put in front of other programmers at the U.S. National Radio Astronomy Observatory (NRAO), where Moore worked with Elizabeth Rather. In 1973 Moore and Rather founded **FORTH, Inc.** to port and commercialize it.1972 · C - C is created
At Bell Labs, **Dennis Ritchie** creates **C** by evolving Ken Thompson's typeless **B**. To suit the byte-addressed PDP-11, Ritchie adds a data-type system (`char`, `int`, structs), a richer expression syntax, and the pointer model that became C's signature. The result is a small, fast, statically (but weakly) typed procedural language - a "portable assembler" close enough to the hardware to be efficient, abstract enough to move between machines.1973 · C - Unix kernel rewritten in C
Thompson and Ritchie rewrite the **Unix kernel** in C, producing **Version 4 Unix** (1973). This was radical: operating systems were assumed to require assembly. Writing the kernel in a high-level language made Unix *portable* - it could move to new hardware by recompiling rather than rewriting - and cemented C's reputation as the systems language. Ritchie and Thompson received the 1983 ACM Turing Award for this work.1978 · C - K&R - The C Programming Language (1st ed.)
**Brian Kernighan** and **Dennis Ritchie** publish *The C Programming Language* on February 22, 1978 - the first widely available book on C. Kernighan wrote the expository chapters; Ritchie's reference manual became the appendix. The dialect it documents, **K&R C**, served as the language's informal specification for the next decade, until ANSI standardization.1979 · C++ - "C with Classes" begun
**Bjarne Stroustrup** begins **C with Classes** at Bell Labs in 1979 - the direct predecessor of C++. He wanted Simula's classes and program-organization features combined with C's efficiency and low-level control. Early additions included classes, derived classes, access control, constructors/destructors, and inline functions, all implemented as a preprocessor (Cpre) that translated to C.1980 · Forth - Forth-79 standard
The **Forth-79** standard is published by the Forth Standards Team, an early community effort to pin down a portable Forth after years of divergent, machine-specific implementations. Together with its successor it became one of the de facto standards that preceded the formal ANS Forth.1983 · C++ - Renamed C++
In 1983 **C with Classes** is renamed **C++** - "C" incremented by the `++` operator. Along with the new name came virtual functions, function and operator overloading, references, `const`, and single-line `//` comments. The name signaled the intent: a strict-enough superset of C that adds object-oriented and higher-level features while keeping C's performance and direct hardware access.1983 · Forth - Forth-83 standard
**Forth-83** is published, revising Forth-79 and changing several well-defined behaviors - integer-division rounding, the operand base of `PICK`/`ROLL`, the value of a "true" flag, the meaning of `NOT`, and the semantics of `'`. The deliberate incompatibilities between Forth-79 and Forth-83 fragmented the community and motivated the eight-year effort that produced ANS Forth.1989 · C - ANSI C (C89)
ANSI standardizes C as **ANSI X3.159-1989**, universally known as **C89** (and, after ISO adopted essentially the same text in 1990, **C90** / ISO/IEC 9899:1990). C89 formalized function prototypes, the `void` and `void *` types, the standard library, and the preprocessor - turning the informal K&R language into a portable, vendor-neutral standard.1994 · Forth - ANS Forth (ANSI X3.215-1994)
The **ANS Forth** standard - **ANSI X3.215-1994** - is published, the definitive Forth standard accepted worldwide. Drafted by a committee formed in 1987 to heal the Forth-79/Forth-83 split, it took 23 meetings over eight years. ANS Forth defines a portable core word set and standardized extension wordsets; it was adopted as an international standard in 1997.1998 · C++ - C++98 - the first ISO standard
The C++ committee publishes the first international standard, **ISO/IEC 14882:1998**, informally **C++98**. It codified the language and, crucially, the **Standard Template Library (STL)** - generic containers, iterators, and algorithms built on templates. A maintenance revision, **C++03** (ISO/IEC 14882:2003), followed in 2003 to fix defects without adding features.1999 · C - C99
**ISO/IEC 9899:1999** (**C99**) modernizes C: `//` line comments, variable-length arrays, the `long long` type, `<stdint.h>` fixed-width integers, `<complex.h>`, `inline` functions, designated initializers, and the ability to declare variables anywhere in a block. C99 brought C closer to everyday programmer ergonomics while keeping its low-level character.2003 · HolyC - TempleOS and HolyC begun
**Terry A. Davis** begins the operating system that would become **TempleOS**, and with it a custom JIT-compiled dialect of C he conceived in the early 2000s and developed alone over roughly a decade - **HolyC**. HolyC sits between C and C++: it makes the compiler an interactive shell where any line of code runs immediately, drops `printf` in favor of a bare `"..."` print statement, defaults `main`-less file execution, and adds language features tightly fused to the OS.2011 · C++ - C++11 - "a new language"
**ISO/IEC 14882:2011** (**C++11**) is the largest revision in C++ history - Stroustrup called it feeling "like a new language." It added `auto` type deduction, range-based `for`, lambdas, move semantics and rvalue references, `nullptr`, `constexpr`, strongly typed `enum class`, variadic templates, `std::unique_ptr`/`shared_ptr` smart pointers, and a standardized threading and memory model.2011 · C - C11
**ISO/IEC 9899:2011** (**C11**) adds multithreading (`<threads.h>`), atomics (`<stdatomic.h>`) and a formal memory model, `_Static_assert`, `_Generic` type-generic expressions, anonymous structs and unions, and bounds-checked `_s` library functions (Annex K). It modernized C for the multicore era while preserving backward compatibility.2013 · HolyC - TempleOS named (HolyC in the world)
In March 2013 the project - previously **J Operating System** (2004-05), **LoseThos** (2006-12), and briefly **SparrowOS** - is renamed **TempleOS**, its final form. Davis wrote over 100,000 lines: a kernel, compiler, graphics system, and applications, all in **HolyC**, a single-address-space, ring-0, JIT-compiled environment. TempleOS made HolyC visible to a wider audience as the canonical example of a one-person operating system.2014 · C++ - C++14
**ISO/IEC 14882:2014** (**C++14**) is a refinement of C++11: generic (polymorphic) lambdas, return-type deduction for ordinary functions, relaxed `constexpr`, variable templates, and binary literals. A smaller, consolidating release that smoothed the rough edges of the C++11 overhaul.2016 · Zig - Zig announced
**Andrew Kelley** begins **Zig** and announces it publicly in 2016. Frustrated building a digital audio workstation - [Go](https://eulingua.scouts-realm.brushtail.me/languages/go)'s GC caused audio glitches, C++ allowed silent memory corruption, and [Rust](https://eulingua.scouts-realm.brushtail.me/languages/rust)'s borrow checker fought him - he set out to build "a better C." Zig's hallmarks: no hidden control flow or hidden allocations, `comptime` compile-time execution in place of macros and generics, explicit error unions, and a C/C++ cross-compiler built in.2016 · Odin - Odin begun
**Ginger Bill** (Bill Hall) starts **Odin** one evening in late July 2016, out of frustration with C++. After a dead-end attempt to build a C preprocessor, he designed a fresh systems language with the "joy of programming" in mind: explicit and simple, with built-in support for SOA/AOS data layouts, distinct array/slice/dynamic-array types, an `Allocator` baked into the language and `context` system, and no hidden control flow. It drew design inspiration from Pascal and from Niklaus Wirth's languages.2017 · Zig - Zig 0.1.0
**Zig 0.1.0** ships on October 17, 2017 - the first tagged release. It established the core syntax, explicit allocator-based memory management, and the error-handling model that define the language. Zig remains pre-1.0, deliberately taking its time to reach "uncompromising perfection" before blessing a stable release.2017 · C++ - C++17
**ISO/IEC 14882:2017** (**C++17**), completed in mid-2017 and published in December, adds structured bindings, `if constexpr`, `std::optional`, `std::variant`, `std::string_view`, fold expressions, guaranteed copy elision, and a standard `<filesystem>` library - a broad set of quality-of-life and vocabulary-type improvements.2018 · C - C17 (C18)
**ISO/IEC 9899:2018** (**C17**, also called C18) is a bug-fix release: it introduced no new language features, instead correcting defects and clarifying ambiguities found in C11. It became the de facto baseline that most toolchains target by default before C23.2019 · Odin - Odin goes public / open source
After about three years as a private project, **Odin** is introduced publicly - shared on Reddit in mid-2019 and developed in the open on GitHub. Backed by an LLVM code-generation backend, it grew a real community and ecosystem, including game-development and graphics users drawn to its data-oriented features.2020 · Zig - Zig Software Foundation founded
Andrew Kelley founds the **Zig Software Foundation (ZSF)**, a 501(c)(3) non-profit, in 2020 to fund full-time work on the language through donations and corporate sponsorship rather than venture capital - a deliberate choice to keep Zig community-governed and independent.2020 · C++ - C++20
**ISO/IEC 14882:2020** (**C++20**), approved September 4 and published December 15, 2020, is another landmark revision. It adds **concepts** (constrained templates), **modules**, **coroutines**, **ranges**, the three-way comparison `<=>` ("spaceship") operator, `consteval`/`constinit`, calendar/timezone support in `<chrono>`, and `std::format`.2022 · Hare - Hare announced
**Drew DeVault** announces **Hare** on April 25, 2022, after about two and a half years of private development. Hare is a small, conservative systems language aimed squarely at C's niche: a hand-written compiler, **no LLVM dependency** (it uses the QBE backend), manual memory management, a tiny standard library, statically linked binaries, and a deliberately stable, modest feature set. It targets FreeBSD, Linux, and similar systems and embraces a "do one thing well" Unix sensibility.2024 · C - C23
**ISO/IEC 9899:2024** (**C23**) is published on October 31, 2024. It makes `bool`, `true`, `false`, `nullptr`, `static_assert`, and `thread_local` first-class keywords, adds `typeof`, binary literals and digit separators, `constexpr` objects, attribute syntax (`[[...]]`), `#embed`, the `<stdckdint.h>` checked-arithmetic header, and `enum` with explicit underlying type. WG14 is now working toward "C2y."

Influence

algol block structure bcplbcpl stripped down to bb added types Cbcpl lean systems style Calgol expression syntax CC extended into C++simula classes / OOP C++algol based on simulaC JIT dialect of HolyCC++ borrows from HolyCC a better C Zigrust reaction to Ziggo simplicity ethos ZigC replaces OdinC++ frustration with Odinpascal syntax & spirit Odinoberon Wirth lineage Odingo package & syntax ideas OdinC modern successor to Harego syntax inspiration Harerust deliberate contrast to HareForth contemporaneous systems peer C