# CGAL: twenty-five years of computational geometry in C++ headers

> The library that made Delaunay triangulations, alpha shapes and boolean operations on polygons a matter of including a header, packaged as roughly a hundred independent packages you can adopt one at a time.

**CGAL/cgal** — The public CGAL repository, see the README below

- Repository: https://github.com/CGAL/cgal
- Website: https://github.com/CGAL/cgal#readme
- Stars: 6,088 · Forks: 1,611
- Language: C++
- License: NOASSERTION
- Published: 2026-10-06 · Updated: 2026-10-06 · Language: en
- Canonical page: https://hysenlabs.com/projects/cgal-cgal

## Header-only since version 5.0, which moved the cost

The single most consequential sentence in the README is the one about version 5.0: CGAL is header-only, meaning it is no longer needed to build CGAL libraries before it can be used. Before that, adopting CGAL meant compiling a set of libraries and linking them. After it, the adoption step is an include path.

That change moved the cost rather than removing it. Compile time went up, because every translation unit that includes a CGAL header now parses a lot of template code. What you get in exchange is a dependency that behaves like the standard library, with no ABI concerns between your build and the library's, and no separate build step in CI to keep in sync.

There is one caveat the README does not spell out but the tree hints at. Most of CGAL is headers now, but the layout still lists component libraries such as `Core`, `CGAL_ImageIO`, `Qt_widget` and `GraphicsView`. The visualization and image I/O parts still compile, because they depend on Qt. So the header-only claim holds for the algorithms, not necessarily for the viewer.

The stated requirement in the README is simply to head to the manual at doc.cgal.org/latest/Manual/general_intro.html for usage guides and tutorials, which is where the real getting-started material lives.

## A repository that is a hundred packages, not a library

The README spends a section explaining that the Git repository has a different layout from release tarballs, which is the kind of warning that saves an afternoon. The repository is organised as a set of subfolders called packages, most of which implement a single data structure or algorithm, with `Convex_hull_2` and `Triangulation_3` given as the examples.

The visible part of the tree runs alphabetically and is a good survey of what the library covers: `AABB_tree` for bounding volume hierarchies, `Advancing_front_surface_reconstruction`, `Algebraic_foundations`, `Algebraic_kernel_d` and the circles and spheres variants, `Alpha_shapes_2` and `Alpha_shapes_3`, `Alpha_wrap_2` and `Alpha_wrap_3`, `Apollonius_graph_2`, `Arrangement_on_surface_2`, `BGL` for the Boost Graph Library algorithms, `Boolean_set_operations_2`, `Bounding_volumes`, `Box_intersection_d`, `Cartesian_kernel`, `Circular_kernel_2` and `_3`, `Classification`, `Combinatorial_map`, `Constrained_triangulation_3`, `Convex_decomposition_3`, `Convex_hull_2`, `_3` and `_d`, `Data`, `Distance_2` and `_3`, `Envelope_2` and `_3`, `Filtered_kernel`, `Frechet_distance`, `Generalized_map`, `Heat_method_3`, and `HalfedgeDS`.

A handful of packages do not implement an algorithm and the README lists them separately: `Installation` for meta-files and CMake support, `Maintenance` for infrastructure, `Testsuite`, `Documentation`, `Scripts` to simplify developer and user work, and `STL_Extension`.

What this means practically is that CGAL is adopted package by package. The directory names in the repository root are also the names you see in the manual's package list, so the two are navigable in parallel.

## The compiler matrix is where the 6.2 notes are most useful

A bug-fix release like 6.2.1 has nothing to say about features, which is why the 6.2 release notes are the ones worth reading in full. The supported compiler list for 6.2 is Visual C++ 15.9, 16.10, 17.14 and 18.0, which corresponds to Visual Studio 2017, 2019, 2022 and 2026, or later. On Linux, Gnu g++ 13.3.0 or later, and LLVM Clang 22.0.0 or later. On macOS, Apple Clang 14.0.0 or later.

Those are unusually recent minimums, and they are the practical constraint that decides whether you can use a given release. A project pinned to an older GCC cannot simply take 6.2; it has to stay on an older CGAL or move its compiler.

The Boost line is stated separately and is more forgiving. The minimal supported version is still 1.74.0, but only versions 1.79.0 and later were tested. That split between minimum and tested is worth noting, because it means a build on 1.74.0 is inside the supported range but outside what the maintainers verified.
The dependency on Boost is a legacy of CGAL's design as a template library built on Boost components, and it is one of the more common complaints about adopting the library: you get Boost as well.

## 2D Alpha Wrapping and what a new package actually means

The headline addition in 6.2 is a new package, 2D Alpha Wrapping, and the release notes describe it in enough detail to be worth reading closely. It takes a polygon soup, a 2D segment soup, and or a 2D point set as input, and generates a valid multi-polygon that strictly encloses that input. The validity is specified: watertight, intersection-free and 1-manifold.

The algorithm shrinks and refines a 2D Delaunay triangulation, starting from a loose bounding box around the input. Two user-defined parameters, the first being alpha, control how tightly the result hugs the input.

This is a useful thing to have in a library because it is genuinely awkward to implement correctly. Turning a messy collection of points and segments into a single clean region is the kind of problem where a naive implementation produces self-intersecting polygons and a careful one needs a lot of case analysis. Alpha shapes, the older related packages `Alpha_shapes_2` and `Alpha_shapes_3`, give you the classical dual-of-Delaunay construction; alpha wrapping gives you a different, more direct answer to a similar question.

Note that this is a new package in a mature library, which means the surrounding infrastructure, the manual entry and the testsuite all had to accommodate it. The tree already had `Alpha_wrap_3`, so the 3D counterpart existed and the 2D version brings the pair together.

## Twice a year tarballs, weekly main branch docs

The README is explicit about distribution: the primary vector of distribution of CGAL are source tarballs, released twice a year and announced on the CGAL web site. There is no binary package, no central build, and no package manager entry in the README. Source tarballs for a header-only library is a defensible choice, since there is nothing to link, but it does mean your build system fetches and compiles.

The release pattern in practice is a feature release in the middle of the year followed by patch releases on the maintained minor lines. Version 6.2 came out on 2026-06-11. Then on 2026-09-04, within a minute of each other by their timestamps, v6.2.1 and v6.1.3 shipped. Both are described as bug-fix releases, and both point at GitHub issue queries filtered by a Merged_in label rather than enumerating changes in prose. 6.1.3 is the interesting one, since it is a patch to the previous minor line, which means CGAL backports fixes rather than dropping old minors.

The documentation tracks that split. There is documentation for the latest release at doc.cgal.org, documentation for the main branch at cgal.geometryfactory.com/CGAL/doc/master updated weekly, and daily testsuite results at cgal.geometryfactory.com/CGAL/testsuite. A daily testsuite result page is a genuinely useful thing for a library this large, because it tells you which configurations are currently green rather than which ones were green on release day.

## 687 open issues, and a license you have to read per package

The repository has 6,054 stars, 1,594 forks and 687 open issues, with the last push on 2026-09-21 and no archive flag. The issue count is the one number that deserves a second look. It is large in absolute terms, and for a project of this age and size with this many contributors, an issue tracker is partly a support channel rather than a defect list. The release notes pointing at GitHub issue queries filtered by a merged-in label is a hint at the workflow: fixes arrive as pull requests that close issues, so the open count tracks incoming work as much as outstanding bugs.

The license needs more care. The README says only: see the file LICENSE.md. The repository metadata does not resolve to a single licence assertion, which is unusual for a project of this size, and it reflects how CGAL distributes licensing across its packages. Some parts of CGAL are under GPL, some are under LGPL, and some are dual-licensed with a commercial option from CGAL's commercial arm. If you are building something you intend to ship, this is the one thing in the README you must not take on trust; read LICENSE.md for the packages you are actually including.

For developers, the repository links guidelines for CGAL developers and information for new developers in the wiki. The presence of `.clang-format`, `.clang-tidy`, `.clangd` and `.markdownlint.json` in the tree shows the same thing from the tooling side: a project that expects contributions to arrive pre-formatted.

## Conclusion

CGAL is the reference implementation for computational geometry in C++, and the practical reason it keeps winning is the package structure: a hundred directories that each solve one problem, so adopting CGAL for convex hulls does not mean compiling a meshing library. Since version 5.0 it has been header-only, which moved the cost from build time to compile time and is the trade most adopters accept willingly. Version 6.2 shipped on 2026-06-11 with the 2D Alpha Wrapping package as its headline addition, and 6.2.1 and 6.1.3 both followed on 2026-09-04 as bug-fix releases, so the maintenance cadence is real. The last push was 2026-09-21. Start with the manual at doc.cgal.org rather than the repository, then check the compiler matrix in the 6.2 notes before you pin a toolchain.

## FAQ

### What does CGAL stand for?

The Computational Geometry Algorithms Library. The README opens with exactly that expansion, followed by a one-line description of it as a C++ library providing easy access to efficient and reliable algorithms in computational geometry.

### Is CGAL header-only, and do I need to build it first?

Since version 5.0, yes. The README states that CGAL is header-only, meaning you no longer need to build CGAL libraries before using them. The cost moves to compile time, and components that depend on Qt, such as GraphicsView and Qt_widget, still compile as libraries.

### What compilers and Boost versions does CGAL 6.2 support?

The 6.2 notes list Visual C++ 15.9 through 18.0, corresponding to Visual Studio 2017, 2019, 2022 and 2026, g++ 13.3.0 or later, LLVM Clang 22.0.0 or later on Linux, and Apple Clang 14.0.0 or later on macOS. The minimal supported Boost is still 1.74.0, though only 1.79.0 and later were tested.

### What is new in CGAL 6.2?

Besides fixes and general enhancements, 6.2 introduces a new package, 2D Alpha Wrapping. It takes a polygon soup, a 2D segment soup and or a 2D point set and produces a watertight, intersection-free and 1-manifold multi-polygon that strictly encloses the input, by shrink-wrapping and refining a 2D Delaunay triangulation.

### How do I get CGAL?

The primary distribution is source tarballs, released twice a year and announced on the CGAL web site. The repository itself is also usable and is organised as packages, with a `CMakeLists.txt` at the root acting as the anchor for configuring and building your own programs against it.

## Sources

- [CGAL/cgal on GitHub](https://github.com/CGAL/cgal)
- [Issues](https://github.com/CGAL/cgal/issues)
- [Project website](https://github.com/CGAL/cgal#readme)
- [README](https://github.com/CGAL/cgal/blob/main/README.md)
- [Releases](https://github.com/CGAL/cgal/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/cgal-cgal