Timeline of C
C from its BCPL and B predecessors in 1967–1969 to the C23 standard published in 2024: Unix, portable compilers, standardization, operating systems, and language revisions.
- Category
- Engineering & Technology
- Tag
- computing
- Events
- 18 events 1967 – 2024
- Generated
- by gpt-6
1967: Richards implements BCPL
Martin Richards implemented Basic Combined Programming Language (BCPL), a compact language for writing compilers and other systems software. Its approach to expressions and machine-level data influenced B and, through B, the design of C.
https://en.wikipedia.org/wiki/BCPL1969: Thompson develops B for early Unix
Ken Thompson developed B at Bell Labs, adapting ideas from Basic Combined Programming Language to the limited memory of the PDP-7. B helped bring higher-level programming to early Unix, but its word-oriented model fit later hardware poorly.
https://en.wikipedia.org/wiki/B_(programming_language)1972: Ritchie develops C from B
Dennis Ritchie added a richer type system and native compilation to B as Unix development moved to the PDP-11. The resulting C language could work directly with bytes, integers, arrays, and pointers while retaining a compact syntax for systems programming.
https://en.wikipedia.org/wiki/C_(programming_language)1973: Bell Labs rewrites Unix in C
Dennis Ritchie and Ken Thompson rewrote the Unix kernel largely in C. Structures and other language improvements made the rewrite practical, demonstrating that a high-level language could implement most of an operating system without giving up direct hardware control.
https://en.wikipedia.org/wiki/Research_Unix1977: C helps move Unix across architectures
Bell Labs brought Unix to the Interdata 8/32 using a retargeted C compiler and a revised kernel. The experiment exposed assumptions about word sizes and addresses, helping establish practical rules for writing C software that could run on different computers.
https://en.wikipedia.org/wiki/Unix1978: Kernighan and Ritchie publish C's reference book
Brian Kernighan and Dennis Ritchie published "The C Programming Language." Its concise tutorial and reference appendix became the working definition of the language before formal standardization, and the dialect it described became known as K&R C.
https://en.wikipedia.org/wiki/The_C_Programming_Language1979: Unix distributes the Portable C Compiler
Version 7 Unix included Stephen Johnson's Portable C Compiler. Separating much of the compiler from machine-specific code made it easier to bring C and Unix software to new processors, supporting the language's spread beyond Bell Labs hardware.
https://en.wikipedia.org/wiki/Portable_C_Compiler1983: A committee begins standardizing C
The American National Standards Institute formed committee X3J11 to define a common version of C. Compilers had accumulated incompatible extensions, so the committee sought to preserve existing practice while specifying language rules and library behavior more precisely.
https://en.wikipedia.org/wiki/ANSI_C1987: Stallman releases the GNU C Compiler
Richard Stallman released the GNU C Compiler as free software. Developers could study, modify, and redistribute a compiler that supported multiple architectures, giving free operating systems and other software a shared foundation for native compilation.
https://en.wikipedia.org/wiki/GNU_Compiler_Collection1989: C receives its first formal standard
The American National Standards Institute approved C's first standard, including function prototypes and a defined standard library. The International Organization for Standardization adopted substantially the same language in 1990, creating the closely related names C89 and C90.
https://en.wikipedia.org/wiki/ANSI_C1991: Torvalds releases a kernel written in C
Linus Torvalds released the first Linux kernel, written mainly in C with assembly for machine-specific operations. Its subsequent development made C central to another major operating-system family and tied the language closely to the free-software toolchain.
https://en.wikipedia.org/wiki/Linux_kernel1995: C gains wider character support
An amendment to the international C standard added facilities for wide and multibyte characters, along with alternative spellings for some tokens. Often called C95, the revision improved support for text and programming environments beyond the original narrow character assumptions.
https://en.wikipedia.org/wiki/ANSI_C1999: C99 expands the language and library
The C99 standard added features including inline functions, variable-length arrays, designated initializers, and standardized integer types. It also permitted declarations within blocks after statements, giving programmers more flexible ways to organize code.
https://en.wikipedia.org/wiki/C992004: Embedded C extensions receive a technical report
An international technical report specified C extensions for embedded processors, including fixed-point arithmetic and named address spaces. The work addressed hardware capabilities that ordinary C did not express consistently across implementations.
https://en.wikipedia.org/wiki/Embedded_C2007: Apple releases Clang as open source
Apple released Clang, a new compiler front end for C and related languages built on the LLVM compiler infrastructure. Its modular design and detailed diagnostics also supported code analysis and development tools beyond ordinary compilation.
https://en.wikipedia.org/wiki/Clang2011: C11 defines a concurrency memory model
The C11 standard introduced atomic operations, a memory model for concurrent execution, and a standard threading interface. It also added generic selection and static assertions, extending the language while allowing implementations to omit some optional facilities.
https://en.wikipedia.org/wiki/C11_(C_standard_revision)2018: C17 consolidates corrections to C11
The revision commonly called C17 was published as the 2018 international standard. It incorporated defect corrections and clarifications from C11 without introducing major language features, giving implementers a consolidated specification.
https://en.wikipedia.org/wiki/C17_(C_standard_revision)2024: C23 becomes a published international standard
The C23 revision was published in October, despite the year in its informal name. It added facilities such as inferred object types, a dedicated null-pointer constant, and standardized attributes, while removing old-style function definitions and requiring two's-complement signed integers.
https://en.wikipedia.org/wiki/C23_(C_standard_revision)