History of the C Programming Language: From Bell Labs to the World (1969–2025)

Before C: The BCPL and B Lineage

To understand where C came from, you need to understand what existed before it. In the mid-1960s, programming languages fell into two uncomfortable camps: high-level languages like FORTRAN and COBOL that were too abstract for systems work, and raw assembly language that was fast but completely machine-specific.

In 1967, Martin Richards at Cambridge University created BCPL (Basic Combined Programming Language) — a typeless language designed for writing system software. It was simple, efficient, and importantly, it had a single data type: the machine word.

Ken Thompson at Bell Labs took BCPL and stripped it down further into a language he called B around 1969, tailoring it for the memory constraints of the PDP-7 minicomputer Bell Labs was using. B kept BCPL's typeless approach but was written specifically for Unix development work.

B's fundamental problem was that it couldn't efficiently handle the varying data sizes of real hardware — bytes, integers, pointers, floating-point numbers all need different sizes, and B treated them all the same. This is the problem Dennis Ritchie set out to solve.

The Birth of C at Bell Labs (1969–1973)

Bell Telephone Laboratories in Murray Hill, New Jersey was one of the most productive research institutions in history. In the late 1960s, its computing research department was working on Multics — an ambitious time-sharing operating system project with MIT and GE. When Bell Labs withdrew from Multics in 1969, a small team led by Ken Thompson decided to build something simpler and more focused.

Thompson started writing Unix on an old PDP-7 minicomputer. The first version was in assembly language — fast but completely tied to that specific machine. Ritchie, who had been studying the B language, began working on a new language that would address B's limitations.

By 1973, enough of C was working that Thompson was able to rewrite the Unix kernel in it — a momentous event in computing history. For the first time, a complete operating system was written in a higher-level language, meaning it could theoretically run on any computer with a C compiler.

/* Early C (pre-ANSI) used a different function declaration style */
/* Known as "K&R style" — note: no types in the parameter list */

int add(a, b)        /* K&R style: params listed after name */
int a, b;           /* types declared separately below */
{
    return a + b;
}

/* Modern ANSI C style (1989 onwards): */
int add(int a, int b) {
    return a + b;
}

C and the Rewriting of Unix

The decision to rewrite Unix in C had consequences that extended far beyond Bell Labs. Because Unix was now portable — able to run on any machine with a C compiler — Bell Labs was able to distribute Unix to universities at low cost under a license agreement.

Through the 1970s and 1980s, Unix spread across university computer science departments worldwide. Students learning to program in this environment learned C. C became inseparable from Unix, and Unix became inseparable from how a generation of developers learned computing.

The C/Unix pairing also created the foundation of the POSIX standard — a set of specifications that define a compatible interface for Unix-like operating systems. Functions you use in C today like open(), read(), write(), fork(), and exec() come directly from the Unix system call interface that C was designed to access.

The K&R Book: The First Standard (1978)

By the mid-1970s, C had spread beyond Bell Labs. Different companies were implementing their own C compilers, and inconsistencies were multiplying. Code that worked on one compiler would fail on another. The community needed a definitive reference.

In 1978, Brian Kernighan and Dennis Ritchie published The C Programming Language — a slim 228-page book that immediately became the authoritative reference for the language. To this day it is simply called "K&R" by programmers.

#include <stdio.h>

main()
{
    printf("hello, world\n");
}

Note the differences from modern C: no return type on main, no return 0;, and lowercase "hello, world" without an exclamation mark. These reflect the more relaxed type rules of pre-ANSI C. The modern version declares int main() and returns 0.

ANSI Standardization: C89 and C90

As C grew in popularity through the early 1980s, the lack of a formal standard became a serious problem. The C compiler market was fragmented — Microsoft, Borland, Unix vendors, and others each had their own dialects with subtle incompatibilities. Code written for one platform often failed to compile cleanly on another.

In 1983, the American National Standards Institute (ANSI) formed a committee — designated X3J11 — to produce a formal standard for C. After six years of work, ANSI C (C89) was published in 1989. The International Organization for Standardization (ISO) adopted it as ISO/IEC 9899:1990 the following year, which is why this version is also called C90.

The Evolution of C: C99, C11, C17, and C23

Since ANSI C, the language has gone through four further official standards. Each added new capabilities while remaining backward-compatible with well-written earlier code.

The People Behind C

C's Legacy: 50 Years of Influence

Few technologies have shaped the modern world as profoundly as C. Consider what would not exist without it: the Linux kernel (and therefore Android, most web servers, and supercomputers), the Windows NT kernel, macOS and iOS foundations, the Python interpreter, the MySQL and PostgreSQL databases, the Git version control system, and the firmware in billions of embedded devices.

C also shaped how we think about programming. Concepts like typed variables, structured control flow, functions, and pointers — all clarified and popularized by C — are now taken for granted in every language. Even languages designed as explicit reactions to C's problems (Java's garbage collection, Rust's borrow checker) only exist because C showed the world what those problems were.

In 2025, C ranks #3 on the TIOBE programming language index — behind only Python and C++. It has never left the top 5 in over 40 years of TIOBE tracking. For a language that turns 53 in 2025, that is a record no other language in history can match.

Frequently Asked Questions