What Is C? The Programming Language Behind Everything Else

C is a compiled, general-purpose programming language created by Dennis Ritchie at Bell Labs in 1972 to write the Unix operating system. It has outlived almost everything from its era, and the reason is simple: C sits one thin layer above the machine. It gives you direct access to memory and to the CPU's real capabilities, while still reading like something a person wrote.

Half a century later it remains the language that other languages are built in.

A Complete C Program

Here is the whole language's shape in six lines. Press Run.

#include <stdio.h>

int main(void) {
    printf("Hello, C!\n");
    return 0;
}

#include <stdio.h> pulls in the standard input/output declarations so printf is known. main is where every C program starts. printf writes text, \n is a newline, and return 0 tells the operating system the program finished successfully. That is a complete, compilable program - there is no class to wrap it in and no framework underneath.

What Makes C Different

Most modern languages hide the machine from you. C deliberately does not.

• It is compiled to native code. A C program becomes machine instructions for one CPU and runs directly, with no interpreter and no virtual machine in between.
• You manage memory yourself. There is no garbage collector. You ask for memory and you give it back. That is more work, and it is also why C programs use so little memory and have such predictable timing.
• It is small. C has about 32 keywords. You can hold the entire language in your head, which is not true of C++, Java, or Python.
• There is almost no runtime. A C program can run on a microcontroller with a few kilobytes of RAM and no operating system at all.

The trade is honesty over safety. C will let you read past the end of an array or use memory you already freed, and it will not stop you. Those mistakes have names - segmentation faults, memory leaks, undefined behavior - and learning C largely means learning to avoid them.

Where C Actually Runs

C is not a historical curiosity. It is running on the device you are reading this on, several times over.

• Operating systems. The Linux kernel is roughly 30 million lines of C. Large parts of Windows and of Apple's kernel are C as well.
• Embedded systems. Microcontrollers in cars, thermostats, medical devices, routers, and washing machines are overwhelmingly programmed in C. When the whole chip has 32 KB of memory, C is often the only realistic option.
• Databases. SQLite, PostgreSQL, MySQL, and Redis are C programs.
• Language runtimes. CPython, the reference Python interpreter, is written in C. So are Ruby's MRI, PHP's Zend engine, and the core of Lua. When Python is "too slow," the fix is usually a C extension.
• Tools and libraries. Git, curl, FFmpeg, OpenSSL, zlib, SQLite again - the infrastructure layer of computing is C.

This is also why C's application binary interface matters: almost every language can call a C function. Python, Rust, Go, Java, and JavaScript all have a way to reach into C libraries. C is the lingua franca between languages.

Why Learn C

There are two honest answers, and they point at different people.

If you want to work on systems software - kernels, drivers, embedded firmware, databases - C is the field's working language, and most job postings in those areas name it directly (often alongside C++ or Rust). It is hard to contribute to Linux, PostgreSQL, or a microcontroller codebase without reading C comfortably.

If you want to be better at the language you already use, C teaches you what is underneath. After C you know why an array index starts at zero, what a string really is, why passing a large object by value is expensive, what the stack and the heap are, and what a null pointer actually points at. Those concepts appear in every language; C is where they are visible instead of hidden.

#include <stdio.h>

int main(void) {
    int x = 42;
    int *p = &x;   /* p holds the address of x */

    printf("value: %d\n", x);
    printf("address: %p\n", (void *)p);
    printf("value through the pointer: %d\n", *p);
    return 0;
}

That program is three lines of C and it is also a complete demonstration of what a variable is: a named box at an address. In most languages you cannot even ask that question.

C and C++

C++ began in 1979 as "C with classes" and grew into one of the largest languages in existence: classes, templates, exceptions, operator overloading, the STL, smart pointers, and a standard library that dwarfs C's entire specification.

The relationship in practice:

• C++ kept C's syntax, so if, for, while, operators, pointers, and arrays look the same in both.
• Most well-written C compiles as C++, with a few exceptions (C++ requires casting the result of malloc, for instance).
• C++ code is almost never valid C.

If you plan to learn both, learning C first is a real advantage: C++ builds directly on C's memory model, and the parts of C++ that confuse people most - pointers, references, copy semantics, destructors - are all answers to problems C shows you plainly.

C is not a subset of C++ in any official sense, though. They are separate standards evolving separately, and modern C has features C++ does not (designated initializers arrived in C99, restrict pointers, and variable-length arrays).

Which C: The Standard Versions

C is standardized, and the version matters when you read older code.

These docs target C17 and call out C99+ features where they matter. Compilers default to something modern, but you can be explicit:

gcc -std=c17 -Wall -Wextra hello.c -o hello

What C Does Not Have

Part of understanding C is knowing what is missing, because almost every "how do I..." question has a different answer here than in a modern language.

• No strings. A C string is an array of char ending in a zero byte. Concatenating two of them means calling a function and worrying about whether the destination is big enough.
• No collections. No lists, maps, or sets. You get fixed arrays and pointers; a hash table is something you write or link a library for.
• No exceptions. Functions report failure by returning a special value - -1, NULL, or a status code - and the caller is expected to check.
• No generics or overloading. One function name means one function. This is why the standard library has abs, labs, and fabs for three different types.
• No namespaces or modules. Every non-static function shares one global namespace, which is why C libraries prefix everything (sqlite3_open, png_read_info).
• No garbage collector. Every malloc needs a matching free, and forgetting is a memory leak.

None of these are oversights. Some are runtime machinery C declines to carry (a garbage collector, exception unwinding, growable strings), which is a large part of why it fits on a chip with 2 KB of RAM; others, like namespaces and generics, are language features that simply postdate C's design and were kept out to keep the language small.

#include <stdio.h>
#include <string.h>

int main(void) {
    char greeting[32] = "Hello";

    /* No + operator for strings - you call a function and manage the space. */
    strcat(greeting, ", world!");

    printf("%s\n", greeting);
    printf("length: %zu characters\n", strlen(greeting));
    return 0;
}

The buffer is 32 bytes because you decided it was enough. C will not check, and that decision is the whole character of the language in one line.

Is C Hard?

C is small but unforgiving. There is not much syntax to memorize - you can read the whole language in a week. What takes time is the discipline: tracking who owns which piece of memory, remembering that a string is just bytes ending in a zero, checking that a pointer is not null before you follow it.

Most of C's difficulty is not in its concepts but in its lack of guardrails: the compiler will not save you from an out-of-bounds write or a dangling pointer, so you learn to be precise. (Pointers themselves take real effort the first time - that is normal, and the pointers chapter takes them slowly.) That precision is a skill that transfers to every language you use afterwards.