C
C family · 1972Actively developedClose to the machine. The foundation of modern systems programming.
Procedural
Links
- Homepage
- https://www.c-language.org/
- Reference / standard
- https://www.open-std.org/jtc1/sc22/wg14/
- WG14 participation
- https://www.open-std.org/jtc1/sc22/wg14/www/contributing.html
- Wikipedia (English)
- https://en.wikipedia.org/wiki/C_(programming_language)
Tracked release
- Version
- C23
- Artifact
- Language standard
- Published
- 2024
- Source checked
- 2026-10-22
Use & ecosystem
- Suited for
- Systems programming, Embedded devices, High-performance graphics, High-performance computing, CLI tools / automation
- Family / tradition
- C-style
- Maturity
- Established
- Ecosystem breadth
- Broad
A stable standardized language, multiple maintained compilers and independent use across operating systems, embedded devices and native libraries support Established and Broad. Individual libraries have separate support lifetimes.
Industry & practical use
C is used in operating-system kernels, device firmware and native libraries. Its ABI is also a common boundary between languages. Graphics APIs and scientific libraries expose C interfaces; NVIDIA provides C tooling for HPC. Application frameworks and hardware SDKs matter more than the small standard library.
Compilers, libraries & tooling
GCC, Clang and vendor compilers cover many processors and operating systems. There is no single reference compiler: the ISO standard defines the language, while compiler versions differ in conformance. Debuggers, sanitizers and C-compatible libraries are extensive, but dependency management is fragmented.
Platforms & deployment
- General toolchains
- Linux, Windows, macOS
- Specialized tooling
- Browser, Android, iOS, Bare metal / microcontrollers
- Browser execution
- WebAssembly
- Native cross-compilation
- Established toolchains
Native toolchains cover Linux, Windows and macOS. Android uses the NDK; Apple SDKs provide native-library tooling. Browser deployment uses Emscripten/WebAssembly. Bare-metal targets require a device-specific compiler target, startup code and hardware support.
GCC and Clang support cross-compilation. A target triple alone is insufficient: headers, libraries, linker and SDK must also match the target. Platform SDK licensing and availability can constrain the build host.
Project health & support
ISO WG14 continues language standardization, alongside independently maintained compiler projects such as GCC and LLVM. Support lifetimes come from the chosen compiler, operating-system vendor or embedded-toolchain supplier; the language standard itself is not a support contract.
Use, ecosystem & platform assessment reviewed 2026-10-22 · Sources below
History & origin
Dennis Ritchie developed C at Bell Labs in the early 1970s, building on B while working on Unix. Its portable model of low-level computation helped Unix spread and shaped generations of later languages.
- Creators
- Dennis Ritchie, Bell Labs
- Origin
- 1972 — First public appearance; earlier development is noted below.
Influences & descendants
Influenced by
Influenced in this catalogue
Language features
- Typing
- Static
- Execution
- AOT
- Block structure
- Explicit delimiters
- Semicolons
- Required
- Lexical closures
- No
- Namespaced modules
- No
- Pattern matching
- No
- Macro system
- Textual preprocessor macros
Implementation notes
- 1972 is a conventional origin year; C emerged through development between 1969 and 1973.
- Macros are textual preprocessor substitutions. They are not syntactic macros.
- Function pointers support callbacks, but standard C has no lexical closures or anonymous functions.
Sources & references
- Language reference
- https://www.open-std.org/jtc1/sc22/wg14/
- History and background
- https://www.nokia.com/bell-labs/about/dennis-m-ritchie/chist.html
- Preprocessor macros
- https://gcc.gnu.org/onlinedocs/cpp/Macros.html
Use, ecosystem & platform sources
- WG14 standardization
- https://www.open-std.org/jtc1/sc22/wg14/
- Compilers and targets
- https://gcc.gnu.org/
- Cross-compilation
- https://clang.llvm.org/docs/CrossCompilation.html
- Linux implementation
- https://docs.kernel.org/process/programming-language.html
- HPC toolchains
- https://developer.nvidia.com/hpc-compilers
- Graphics interfaces
- https://wgpu.rs/
- Android NDK
- https://developer.android.com/ndk/guides
See the classification definitions for implementation-dependent features. Influence links cover the entries documented here.