gcc.gnu.org

GCC (the GNU Compiler Collection) ships front ends for C, C++, Objective-C, Objective-C++, Fortran, Ada, Go, D, Modula-2, COBOL, Rust, and Algol 68, plus libraries for these languages such as libstdc++. That list comes from the project's own description of itself on gcc.gnu.org, so it reflects what the collection officially includes rather than what a single installed build might have enabled. If your project is written in one of those languages, GCC is a candidate toolchain; whether it is the right one depends on your target platform and how your distribution packages the compilers.

The full language list

According to the GCC project page, the collection includes front ends for:

• C
• C++
• Objective-C
• Objective-C++
• Fortran
• Ada
• Go
• D
• Modula-2
• COBOL
• Rust
• Algol 68

Alongside the front ends, GCC provides libraries for these languages — the page names libstdc++ as an example, which is the C++ standard library implementation that ships with GCC.

What "front end" means here

A front end is the part of the compiler that parses a particular language and turns it into GCC's internal representation. The back end then generates code for your target. This is why one compiler collection can cover so many languages: adding a language means adding a front end, not rebuilding the whole toolchain.

A practical consequence: the language list describes the collection as a whole, not necessarily your local gcc binary. A default build on many systems enables C and C++ and little else. Fortran, Ada, Go, D, and the rest are often packaged as separate commands (gfortran, gnat, gdc, and so on) or separate distribution packages.

One caveat: Algol 68 is experimental

The project's news notes that an experimental Algol 68 front end was added to GCC. "Experimental" is the operative word — treat Algol 68 support as a work in progress rather than a stable, production-ready target, and check the current release notes before relying on it.

How to check what your build actually supports

The list above tells you what GCC can support; your installation tells you what it does support. To find out:

1. Run gcc -v and read the "Configured with" line — it shows which languages were enabled when the compiler was built.
2. Try invoking the language-specific driver directly, for example gfortran --version or gdc --version. If the command exists, that front end is installed.
3. On a distribution, check your package manager for separate language packages (for example, a Fortran or Ada package) if the driver is missing.

The expected result is a version string for each language you have; a "command not found" means that front end is not installed, even though GCC as a project supports the language.

Choosing GCC for your language

• C, C++, Fortran, Ada, Go, D, Modula-2, COBOL, Rust, Objective-C/C++: GCC lists a front end for each, so it is worth evaluating against your platform and existing build setup.
• Algol 68: available only as an experimental front end — verify current status before committing.
• A language not on the list: GCC is not the tool for it; look elsewhere.

For release status and which versions are currently maintained, the project's "Supported Releases" section on gcc.gnu.org is the authoritative place to check before you pick a version to build against.

GCC source code is available in two main forms: through Git and through weekly snapshots. The project also invites outside contributions and testing. If you want to build GCC yourself, track development, or help test releases, start with the Git repository or a snapshot, then use the mailing lists and other community channels listed on gcc.gnu.org to coordinate with maintainers.

Getting the source code

The GCC project states that its sources are "readily and freely available via Git and weekly snapshots." That gives you two practical routes depending on what you need.

If your goal is to contribute a change, Git is the natural choice because patches are reviewed against the current tree. If you only want to compile a recent version or test a specific state, a snapshot may be simpler.

Contributing changes or testing

The site explicitly encourages everyone to "contribute changes or help testing GCC." Testing is a real contribution path, not a consolation prize: the project aims for "regular, high quality releases" that work across many native and cross targets, including GNU/Linux, and that goal depends on people running the compiler and reporting results.

A practical starting sequence:

1. Get the source via Git or a snapshot.
2. Build it for a target you actually use.
3. Run the test suite or compile your own code and note failures.
4. Report findings through the project's community channels.

The exact build commands and test-suite invocation depend on your platform and the version you checked out, so follow the installation and platform documentation linked from the site rather than assuming a fixed procedure.

Staying informed and participating

GCC announcements and coordination happen through several channels referenced on the site:

• Mailing lists — the primary place for development discussion and announcements.
• IRC — the project lists an @gnutools presence.
• Mastodon — also listed under @gnutools.
• News on the homepage — release announcements and event notices appear there, such as "GCC 16.2 released" and "GCC 15.3 released."

The site also notes that major decisions about GCC are made by a steering committee guided by a mission statement, so proposals and direction-setting go through that governance structure rather than being decided ad hoc.

Choosing a release to work against

If you plan to contribute or test, the supported releases page tells you which versions are in maintenance mode versus open development. Recent entries include:

• GCC 16.2 — status dated 2026-08-07, regression fixes and docs only.
• GCC 15.3 — status dated 2026-06-12, regression fixes and docs only.
• GCC 14.4 — status dated 2026-06-19, regression fixes and docs only.
• GCC 17.0 — development, status dated 2026-04-22, general development.

For new feature work, the development release is the relevant target. For bug fixes intended to reach users quickly, a maintained release branch is usually the right place. Each release entry links to its changes and to lists of serious and all regressions, which is useful when deciding whether a problem you hit is already known.

What gcc.gnu.org provides

The site is the project's home for releases, documentation, installation and platform notes, snapshots, mailing lists, and contributor information. It covers front ends for C, C++, Objective-C, Objective-C++, Fortran, Ada, Go, D, Modula-2, COBOL, Rust, and Algol 68, along with libraries for these languages such as libstdc++. GCC was originally written as the compiler for the GNU operating system, and the project describes the GNU system as developed to be 100% free software in the sense of respecting the user's freedom.

If you are new to the project, the most useful first steps are to read the mission and releases pages, pick a supported release or the development tree, and join a mailing list before sending patches.

GCC (the GNU Compiler Collection) is the GNU Project's compiler suite, and gcc.gnu.org is its official home site. It is the place to check current release status, read documentation, get the source via Git or weekly snapshots, and follow project news. It is most useful if you want to compile C, C++, or one of the other supported languages, or if you want to track or contribute to GCC development. The site itself is informational — it points you to releases, docs, and mailing lists rather than hosting an online compiler.

What GCC actually is

GCC is a collection of language front ends plus the supporting runtime libraries. According to the site, it includes front ends for:

• C, C++, Objective-C, Objective-C++
• Fortran, Ada
• Go, D, Modula-2, COBOL
• Rust, Algol 68

It also ships libraries for these languages, such as libstdc++. GCC was originally written as the compiler for the GNU operating system, which was developed to be 100% free software — free in the sense that it respects the user's freedom. That framing matters: GCC is not just a tool, it is a GNU Project component with an explicit software-freedom mission.

What gcc.gnu.org offers

The site is organized around a few practical resources:

There is also a site search with options for matching all words, any word, or a Boolean expression, sorted by newest or best match, plus a detailed search form.

Current releases and how to read the status

The Supported Releases section lists each version with a date and a status note. As shown on the site:

• GCC 16.2 — status 2026-08-07 (regression fixes & docs only)
• GCC 15.3 — status 2026-06-12 (regression fixes & docs only)
• GCC 14.4 — status 2026-06-19 (regression fixes & docs only)
• Development: GCC 17.0 — status 2026-04-22 (general development)

The "regression fixes & docs only" label is the key detail: those branches are in maintenance, so expect bug fixes and documentation updates rather than new features. If you need new functionality, the development branch is where it lands. Each entry links to its own changes page and to serious/all regression queries, which is how you check whether a known bug affects the version you are considering.

How development and governance work

GCC is developed in the open. Sources are available via Git and weekly snapshots, and the project encourages contributions and testing help. Major decisions are made by a steering committee guided by a mission statement. Recent news items illustrate the pace and scope of the project:

• GCC AI Policy announced (2026-07-29)
• GCC 13.5, 16.2, 14.4, 15.3, and 16.1 releases across 2026
• An experimental Algol 68 front end added (2025-11-30)
• GNU Tools Cauldron 2026 in Prague, October 2–4, 2026
• FOSDEM 2026 developer room in Brussels, January 31 – February 1, 2026

When this site is the right starting point

Use gcc.gnu.org if you want to:

• Confirm which GCC versions are currently supported and what state they are in
• Download source through Git or a weekly snapshot
• Find installation and platform documentation
• Join mailing lists or follow announcements
• Understand who decides what in the project

If you just want a compiler installed and working on your machine, the site's documentation and platform pages are the relevant entry point; the site does not itself compile code for you.

As of the GCC project's own release page, four release lines are listed as supported or in development: GCC 16.2, GCC 15.3, GCC 14.4, and the development series GCC 17.0. The three numbered stable releases are in a regression-fix-only phase (plus documentation changes), while GCC 17.0 is in general development. Each entry links to its own changes page, serious regressions, and all regressions, so you can check exactly what is still being fixed before deciding which compiler to install or pin in a build system.

Supported stable releases

All three carry the same status wording: regression fixes & docs only. In practice this means the release branch is closed to new features and general changes; maintainers accept fixes for regressions (things that used to work and broke) and documentation updates. If you are choosing a compiler for a new project, this tells you the branch is stable but no longer gaining functionality.

What each release page gives you

For every listed release, the site provides three follow-up links:

• changes — what changed in that release relative to earlier ones.
• Serious regressions — the tracked list of high-impact regressions.
• All regressions — the full regression list for that branch.

Checking the regression links is the practical way to judge whether a known bug affecting your code has been fixed in the branch you plan to use.

Development release

GCC 17.0 is listed under Development with status date 2026-04-22 and the phase general development. It links to release criteria and changes. Because it is the active development line, it receives new features and broader changes rather than only regression fixes — expect it to be less settled than the numbered stable releases.

How to use this to decide

• Need maximum stability for production builds: pick the newest stable line, GCC 16.2, and confirm your specific issue is not on its regression lists.
• Pinned to an older toolchain or a distro that ships it: GCC 15.3 or 14.4 may be the relevant branch; both are still receiving regression and documentation fixes.
• Want upcoming features or are testing against the next release: GCC 17.0 is the development series, governed by its release criteria.

One caveat: the page lists these as the supported releases at the time shown, but release status changes over time. The News section on the same site is where new releases are announced (for example, "GCC 16.2 released [2026-08-07]"), so re-check it if you need the current state rather than a snapshot.