YOUR C LEARNING COMPANION

Find your next idea.

Learning path
C in contextChapter 68 of 73

C’s timeline: history, editions, and standards

Trace C’s development and published revisions, and distinguish nicknames, dates, drafts, and compiler modes.

6 min readFoundationsHistory + standards
Offline reading
In this chapter9 sections

C has changed through several published editions. A revision’s nickname, publication year, and compiler mode can use different dates or names. This timeline helps you place an older explanation and check which rules apply.

1. C developed through earlier languages and Unix

BCPL, B, and C are related languages, not three names for one unchanged language. Adding a richer type model let C describe characters, integers, pointers, and structured data while remaining useful for systems work. The PDP-11 environment influenced early choices, but the language was later adapted for other targets.

Ritchie’s account distinguishes the early creative period from later portability work. Rewriting the Unix kernel in C demonstrated usefulness; it did not prove that every C program would run unchanged on every computer. The earlier origins chapter gives the beginner narrative.

2. The milestones and what each changed

Period / publicationMilestoneMeaning
1960s / 1969–1970BCPL → BMartin Richards’s BCPL and Ken Thompson’s B form the lineage from which C developed.
1971–1973C developsRitchie develops C’s type structure; 1972 is a key creative period, not a single instant invention.
1973PDP-11 Unix kernelThe kernel rewrite demonstrates practical systems use; later portability work is still needed.
1978 / 1988K&R editionsThe first book describes an evolving language; the second reflects the standardization period. A book edition is not an ISO revision.
1983ANSI X3J11A committee begins standardization work, rather than inventing C from nothing.
1989 / 1990C89 / C90ANSI X3.159-1989 is followed by ISO/IEC 9899:1990; these names usually identify the same foundational standardized revision.
1995C95 amendmentThe 1990 standard receives an amendment, including wider international-character library facilities and alternative tokens.
1999C99Adds facilities such as // comments, mixed declarations/statements, inline, and variable length arrays. Later revisions adjust some support requirements.
2011C11Adds a memory model, atomic/thread facilities, generic selection, and static assertions; some facilities have conditional support.
2018C17 / C18ISO/IEC 9899:2018 incorporates corrections to C11. C17 is the common nickname; C18 follows its publication year.
2024C23ISO/IEC 9899:2024 publishes the revision commonly called C23, with new declaration, preprocessing, and library facilities.
2026 checkC2y workWG14 lists the next main revision as unpublished. Drafts, proposals, and separate technical specifications have their own status.

3. A book, a draft, and a standard serve different jobs

A published standards revision specifies the language/library contract for that edition. A committee draft shows wording at a particular stage; it can differ from the final publication. A proposal suggests a change and may be rejected or revised. A compiler extension can be useful without belonging to the selected ISO edition.

A separate Technical Specification is another publication, not automatically part of the main C standard. As checked on 31 October 2026, WG14 lists C23 as published and C2y as ongoing work. Its project page even identifies N3220 as an early C2y draft; calling every newer draft “the C23 standard” would erase that distinction.

4. Nicknames and publication years can differ

C17 is published as 9899:2018; C23 as 9899:2024. The nickname is not an instruction to rewrite the ISO date. A tutorial saying “C17” and a catalogue saying “2018” need not contradict each other. Check the edition and relevant rule, not just the largest year printed on a page.

Optional: inspect a selected compiler mode

This complete C17 example prints the implementation’s standard-version macro when it is defined. The displayed GCC commands select C17 explicitly; these commands are a toolchain convention, not C source syntax.

C17 · project file · version.c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
#ifdef __STDC_VERSION__
    if (printf("%ld\n", (long)__STDC_VERSION__) < 0) return EXIT_FAILURE;
#else
    if (puts("No __STDC_VERSION__ macro") == EOF) return EXIT_FAILURE;
#endif
    return fflush(stdout) == EOF ? EXIT_FAILURE : EXIT_SUCCESS;
}
GCC / GNU tools · example commands
gcc -std=c17 -pedantic-errors -Wall -Wextra version.c -o version
./version

In the selected C17 mode the output is 201710. C99 uses 199901L, C11 201112L, and a conforming C23 mode 202311L. An older preview mode can report a draft value. The macro alone does not inventory every optional header, target rule, or runtime facility.

5. How to read an older resource responsibly

Identify its intended edition, separate historical syntax from today’s rules, and check changed facilities in a current reference. Old implicit function declarations and identifier-list definitions are not the C17 teaching style here. A familiar compiler accepting something as an extension is evidence about that mode, not a reason to label the construct portable C.

Keep an older explanation when its contract still holds. Recheck version-sensitive topics such as prototypes, const/constexpr, allocation, initialization, enums, and library support against the C23 migration chapter.

6. Thought check: does a newer-looking document supersede everything?

A working draft is dated after the published standard. Can I treat all its rules as published C23?

No. Check what revision the draft targets and the status of each change. A draft can describe future work; a separate specification can remain separate. Publication status and implementation availability are different questions.

Sources and further reading

Before you move on

  • C’s published editions and working drafts have different status.
  • A nickname such as C23 can differ from the ISO publication year.
  • An older resource should be interpreted using its intended edition and current implementation support.
Keep these ideas separate
Proposal / Published standard
A discussed or adopted proposal must be checked against the selected published edition and any relevant implementation conditions.
Explain it in your own words

Which dates and version claims would you check before using a feature from an older book or a compiler preview mode?

Optional: say it aloud or keep a note. You can continue whenever you are ready.

Check your understanding

Optional. Answers are not saved or sent, and reading stays unrestricted.

Why identify the language edition when reading an old C example?
Read the explanation for every choice
  1. Every old convention is required by modern C.

    Historical practice and a current language requirement are different things.

  2. Rules and available features can differ between editions.

    ✓ Correct reasoning. Check the example’s edition and assumptions before treating it as a portable rule.

  3. A publication date alone proves compiler support.

    Implementation support must be checked separately from a standard’s publication.

General

Quick reference from the earlier edition

Retained for existing section links and saved passages. Exact corrections are documented in the source review.

C's evolution reflects both practical needs and the drive for portability and consistency across platforms. The following timeline highlights key milestones in the language's development:

  • 1960s: BCPL developed by Martin Richards.
  • 1969–1970: Ken Thompson develops B at Bell Labs.
  • 1972: A key year in Ritchie's development of C and its type system; the language continues to evolve.
  • 1973: The Unix kernel for the PDP-11 was rewritten in C, demonstrating the language’s usefulness for system implementation.
  • 1978: Brian Kernighan and Dennis Ritchie publish "The C Programming Language" (K&R C), providing the first widely available description of the language.
  • 1983: ANSI X3J11 committee formed to standardize C.
  • 1989: ANSI C (C89) standard published, providing a common language and library specification while retaining specified implementation choices.
  • 1990: ISO adopts ANSI C as ISO/IEC 9899:1990 (C90).
  • 1999: C99 standard introduces features like variable-length arrays, inline functions, and single-line comments.
  • 2011: C11 standard adds multithreading support, atomic operations, and improved Unicode handling.
  • 2018: C17 standard, a maintenance release, clarifies and fixes issues in C11.
  • 2024: C23 standard introduces modern features such as nullptr, binary literals, digit separators, and further library improvements.

Each standard has built upon its predecessors, refining the language, enhancing safety and portability, and responding to the needs of modern software development.

Ready for the next idea?

Mark this chapter as read whenever you feel ready.

CHAPTER 68 / 73

In this chapter

C’s timeline: history, editions, and standards

Search all 73 chapters in both languages.EN + HG

Try “pointer”, “why int”, or “undefined behavior”.

Concepts connect. Follow your curiosity.↑ ↓ to explore · Enter to open
MAKE YOURSELF COMFORTABLE

Your reading space

Appearance

A clear canvas with balanced contrast.

Text size

100%
AA

Reading tools

Your data stays in this browser

Export a backup before changing browsers or replacing an older version of the reader.

YOUR PERSONAL MARGINS

My notebook

Saved on this device
A LITTLE CLARITY

The glossary

A starting meaning, then a chapter to go deeper.

A QUICK DEFINITION

A little clarity

Read the full explanation →

A thought worth keeping