# GNU Compiler Collection
The GNU Compiler Collection (GCC) is a free-software compiler suite that translates source code in C, C++, Objective-C, Objective-C++, Fortran, Ada, Go, D, Modula-2, COBOL, Rust, and Algol 68 into machine code, together with runtime libraries for these languages such as libstdc++[1](https://gcc.gnu.org/index.html). It was originally written as the compiler for the GNU operating system, a system developed to be 100% free software in the sense that it respects the user's freedom[1](https://gcc.gnu.org/index.html). The project publishes regular releases that work on a variety of native and cross targets, including GNU/Linux, and major decisions are made by a steering committee guided by a mission statement[1](https://gcc.gnu.org/index.html).
| Key fact | Detail |
|---|---|
| First release | Beta 0.9 on March 22, 1987; version 1.0 on May 23, 1987[2](https://gcc.gnu.org/releases.html) |
| Name | Officially "GNU Compiler Collection"; historically "GNU C Compiler", a usage still common for the C compiler[3](https://gcc.gnu.org/onlinedocs/gcc/G_002b_002b-and-GCC.html) |
| Languages | Front ends for C, C++, Objective-C, Objective-C++, Fortran, Ada, Go, D, Modula-2, COBOL, Rust, and Algol 68[1](https://gcc.gnu.org/index.html) |
| Recent releases | GCC 16.1 (April 30, 2026), GCC 16.2 (August 7, 2026); development trunk is GCC 17.0[2](https://gcc.gnu.org/releases.html) |
| New front ends | COBOL added April 17, 2025 (contributed by COBOLworx); experimental Algol 68 added November 30, 2025[4](https://www.gnu.org/software/gcc/index.html) • [1](https://gcc.gnu.org/index.html) |
| Internal representations | GENERIC and GIMPLE trees for high-level optimization, then the RTL representation for machine-level work[5](https://gcc.gnu.org/onlinedocs/gccint/) |
| Bootstrap requirement | GCC before 15 bootstraps with an ISO C++11 compiler, before 10.5 with ISO C++98, before 4.8 with ISO C89[6](https://gcc.gnu.org/install/prerequisites.html) |
## Languages and front ends
GCC is an integrated distribution of compilers for several major programming languages[3](https://gcc.gnu.org/onlinedocs/gcc/G_002b_002b-and-GCC.html). The part of a compiler specific to a particular language is the front end; the language-independent component, shared by all the compilers, contains most of the optimizers and the back ends that generate machine code for various processors[3](https://gcc.gnu.org/onlinedocs/gcc/G_002b_002b-and-GCC.html).
For languages besides C, the compilers generally carry distinct names: G++ handles C++, gcobol handles COBOL, and GNAT handles Ada.[3](https://gcc.gnu.org/onlinedocs/gcc/G_002b_002b-and-GCC.html) In addition to the integrated front ends, several others, supporting languages such as Mercury, are maintained separately and must be built together with GCC proper[3](https://gcc.gnu.org/onlinedocs/gcc/G_002b_002b-and-GCC.html).
The language roster keeps growing. The COBOL front end was added on April 17, 2025, contributed by COBOLworx[4](https://www.gnu.org/software/gcc/index.html), and an experimental Algol 68 front end followed on November 30, 2025[1](https://gcc.gnu.org/index.html). None of the included compilers is implemented as a preprocessor that emits another high-level language such as C, a design once common for C++ and Fortran compilers; they all generate machine code directly[3](https://gcc.gnu.org/onlinedocs/gcc/G_002b_002b-and-GCC.html).
## History and releases
The release timeline begins with beta 0.9 on March 22, 1987, followed by a rapid series of 1.x releases through 1987 and 1988, with version 1.0 dated May 23, 1987[2](https://gcc.gnu.org/releases.html). The project now maintains several release branches in parallel, each receiving regression fixes and documentation updates only. As of mid-2026 the supported releases are GCC 16.2, 15.3, 14.4, and 13.5, while GCC 17.0 is in general development on the trunk[1](https://gcc.gnu.org/index.html).
Hardware support changes over time. Deprecation of Intel Itanium (IA-64) support returned to the agenda for GCC 16 after a revival the previous year[7](https://www.tomshardware.com/software/linux/intels-fabled-itanium-refuses-to-die-but-the-end-is-probably-near-deprecation-of-ia-64-support-is-back-on-the-chopping-block-in-gcc-version-16).
## Architecture and internals
The internals manual describes a pipeline of representations. Front ends parse source into GENERIC trees, which are lowered to GIMPLE, a typed representation on which the analysis and optimization passes operate; the RTL representation then carries machine-level code generation[5](https://gcc.gnu.org/onlinedocs/gccint/). Target support is described through machine descriptions and target description macros, and the manual also documents the low-level runtime library, the control flow graph, loop analysis, plugins, and link-time optimization[5](https://gcc.gnu.org/onlinedocs/gccint/).
A structural contrast with LLVM is often drawn: GCC maintains a separate back end for each target architecture, while LLVM utilizes a shared target-independent code generator with target-specific back ends for different architectures[8](https://ieee-hpec.org/wp-content/uploads/2024/09/183.pdf) • [16](https://llvm.org/docs/WritingAnLLVMBackend.html). GCC selects instructions with a pattern-matching approach, whereas LLVM uses a table-driven approach based on a target description[8](https://ieee-hpec.org/wp-content/uploads/2024/09/183.pdf).
## Building GCC
GCC is built from source, and a native build by default performs a 3-stage bootstrap when `make` is invoked, testing that GCC can compile itself correctly[9](https://gcc.gnu.org/install/configure.html). The bootstrap requirement has risen over the years: versions prior to 15 can be bootstrapped with an ISO C++11 compiler, versions prior to 10.5 with an ISO C++98 compiler, and versions prior to 4.8 with an ISO C89 compiler[6](https://gcc.gnu.org/install/prerequisites.html). Building all languages in a configuration without a 3-stage bootstrap requires starting from an existing GCC binary, because front ends other than C and C++ may use GCC extensions in their own source[6](https://gcc.gnu.org/install/prerequisites.html).
## Tools and diagnostics
The distribution ships more than compilers. The gcov program measures test coverage, with companion tools gcov-tool for offline profile processing, gcov-dump for dumping profile data, and lto-dump for link-time optimization object files[10](https://gcc.gnu.org/onlinedocs/gcc/). Since GCC 13 the compiler has included a static analyzer enabled with `-fanalyzer`, which issues warnings such as `-Wanalyzer-double-free`, `-Wanalyzer-use-after-free`, `-Wanalyzer-file-leak`, and `-Wanalyzer-tainted-array-index`, each mapped to a corresponding Common Weakness Enumeration entry[11](https://gcc.gnu.org/onlinedocs/gcc/Static-Analyzer-Options.html).
GCC's C extensions matter beyond the compiler itself. The [Linux kernel](https://www.edgepedia.org/linux-kernel) is written in C and is typically compiled with `gcc` under `-std=gnu11`, the GNU dialect of ISO C11, and it relies on GNU attributes and other extensions throughout; building with `clang` is also supported[12](https://www.kernel.org/doc/html/latest/process/programming-language.html).
## GCC and Clang in practice
GCC and LLVM's Clang are the two dominant open-source C and C++ compilers, and measured performance differences between them are workload- and architecture-dependent. A 2025 study of vectorization on x86 and ARM reported that on x86, GCC vectorized 54% of the loops in the test suite, the Intel ICX compiler 50%, and Clang 46%, while concluding that no compiler is definitively better at vectorizing on any given platform[13](https://arxiv.org/abs/2502.11906). On AArch64 HPC systems the picture varies by benchmark: in one comparison on NVIDIA Grace Hopper and [Fujitsu A64FX](https://www.edgepedia.org/fujitsu-a64fx) hardware, GCC produced the best and most consistent GEMM results on both machines, while LLVM outperformed GCC on the MiniBude molecular dynamics code on [Grace Hopper](https://www.edgepedia.org/grace-hopper) when SVE was enabled[8](https://ieee-hpec.org/wp-content/uploads/2024/09/183.pdf).
GCC's footprint is large enough that it serves as a workload in its own right: the [SPEC CPU](https://www.edgepedia.org/spec-cpu) 2026 benchmark suite includes code compilation with GCC as a benchmark in both its SPECrate and SPECspeed integer suites[14](https://www.tomshardware.com/pc-components/cpus/new-server-focused-spec-cpu-2026-benchmarking-suite-has-results-for-a-raspberry-pi-5-updated-tools-feature-more-tests-and-can-run-a-wide-range-of-systems). Compiler choice also affects published hardware results; when AMD benchmarked its EPYC "Venice" processors against Nvidia's Vera with SPEC CPU 2026, it used GCC 16.1 while Nvidia's white paper had used GCC 15.2, a mismatch that can have a substantial impact on the comparison[15](https://www.tomshardware.com/pc-components/cpus/amd-shares-first-official-benchmarks-for-epyc-venice-cpus-targets-nvidia-company-claims-256-core-chip-is-more-than-twice-as-fast-as-nvidia-vera-96-core-model-20-percent-faster-per-core).
## References
1. [GCC, the GNU Compiler Collection - GNU Project](https://gcc.gnu.org/index.html)
2. [GCC Releases - GNU Project](https://gcc.gnu.org/releases.html)
3. [G++ and GCC, Using the GNU Compiler Collection](https://gcc.gnu.org/onlinedocs/gcc/G_002b_002b-and-GCC.html)
4. [GCC, the GNU Compiler Collection - GNU Project (gnu.org)](https://www.gnu.org/software/gcc/index.html)
5. [GNU Compiler Collection (GCC) Internals](https://gcc.gnu.org/onlinedocs/gccint/)
6. [Prerequisites for GCC - GNU Project](https://gcc.gnu.org/install/prerequisites.html)
7. [Intel's Itanium deprecation back on the chopping block in GCC 16, Tom's Hardware](https://www.tomshardware.com/software/linux/intels-fabled-itanium-refuses-to-die-but-the-end-is-probably-near-deprecation-of-ia-64-support-is-back-on-the-chopping-block-in-gcc-version-16)
8. [Comparative Analysis of GCC and LLVM for Performance Optimization on AArch64, IEEE HPEC](https://ieee-hpec.org/wp-content/uploads/2024/09/183.pdf)
9. [Installing GCC: Configuration - GNU Project](https://gcc.gnu.org/install/configure.html)
10. [Top, Using the GNU Compiler Collection (GCC)](https://gcc.gnu.org/onlinedocs/gcc/)
11. [Static Analyzer Options, Using the GNU Compiler Collection (GCC)](https://gcc.gnu.org/onlinedocs/gcc/Static-Analyzer-Options.html)
12. [Programming Language, The Linux Kernel documentation](https://www.kernel.org/doc/html/latest/process/programming-language.html)
13. [Comparison of Vectorization Capabilities of Different Compilers for X86 and ARM CPUs, arXiv](https://arxiv.org/abs/2502.11906)
14. [SPEC CPU 2026 benchmarking suite, Tom's Hardware](https://www.tomshardware.com/pc-components/cpus/new-server-focused-spec-cpu-2026-benchmarking-suite-has-results-for-a-raspberry-pi-5-updated-tools-feature-more-tests-and-can-run-a-wide-range-of-systems)
15. [AMD EPYC Venice benchmarks vs Nvidia Vera, Tom's Hardware](https://www.tomshardware.com/pc-components/cpus/amd-shares-first-official-benchmarks-for-epyc-venice-cpus-targets-nvidia-company-claims-256-core-chip-is-more-than-twice-as-fast-as-nvidia-vera-96-core-model-20-percent-faster-per-core)
16. [Writing an LLVM Backend - LLVM](https://llvm.org/docs/WritingAnLLVMBackend.html)
---
*Topic: Encyclopedia › Technology and the built world › Computing and digital systems › Software and programming › Compilers, interpreters, and toolchains*
*Initially written Sep 17, 2026 · Reviewed: Sep 30, 2026; Oct 15, 2026 · Edited: Sep 30, 2026; Oct 15, 2026 · Last review: Oct 15, 2026*
*Copyright 2026 EdgeChat AI, a subsidiary of Biostate AI.*
License: Edgepedia Community License 1.0, https://www.edgepedia.org/edgepedia/license