A C/C++ Build System/Package Manager Comparison

Overview

This article is a opinionated comparison of popular, open-source build systems/package managers for C/C++. This review looks at both programs that compile your code and those that manage dependencies, as the line between build systems and package managers is blurred. The build and packaging support are treated as separate qualities which will be reviewed for each.

The build systems are listed in alphabetical order.

The GitHub repository mbedded-ninja/CppBuildSystemReview contains a example/demo project for each build/packaging system mentioned below (one per folder). In each folder, there is a build.sh bash script which should automatically run the build on a Linux system, provided you have the build system installed.

The Opinionated TL;DR

If you want a full end-to-end package manager and build system setup, have a look at Conan with CMake. If you just are after a modern, powerful build system for typical build situations, have a look at Bazel. If you are thinking about cross-compiling (e.g. embedded targets), want something mature and well-known, or have a complicated build structure, have a look at CMake by it’s own.

If you are thinking of using Scons or Makefiles, please make sure you are doing so for a good reason! Perhaps it’s because it has to integrate with a system that already uses these tools, or that is what your company prefers. If you are considering it for a completely new project, I strongly recommend you consider some of the alternatives!

Bazel

• Website: https://bazel.build/
• Code: https://github.com/bazelbuild/bazel
• Slogan:

Bazel is developed by Google.

Bazel has some decent package manager support in the form of external dependencies. Bazel supports other local Bazel repositories, non-Bazel projects, and remote repositories which can be automatically downloaded by Bazel.

Cross-compilation using Bazel can be difficult (see https://github.com/bazelbuild/bazel/wiki/Building-with-a-custom-toolchain for reasons why).

As far as I’m aware, Bazel does not have the install functionality that build systems such as make and CMake have. The is no way to “install” the build executables, libraries and header files onto the system, be it the typically install locations (such as /usr/local/bin, /usr/local/lib, e.t.c. on Linux) or a custom install directory.

Bazel seems to have first tier build support for C/C++, Java, Android and iOS.

Buck

• Website: https://buckbuild.com/
• Code: https://github.com/facebook/buck
• Slogan: A high-performance build tool

Buckaroo

• Website: https://buckaroo.pm/
• Code: https://github.com/LoopPerfect/buckaroo
• Slogan: A C++ package manager that will take you to your happy place

Buckaroo is a package manager that uses Buck as the build system.

Unfortunately, I do not believe that Buckaroo supports local dependencies. All dependencies have to come from

CMake

• Website: https://cmake.org/
• Code: https://gitlab.kitware.com/cmake/cmake
• Slogan: Build with CMake. Build with Confidence.

CMake is a C/C++ build system which strives to be operating system and compiler independent. CMake itself does not actually run the build process, instead, it generates build files for another build system, which is typically make on UNIX systems and Visual Studio on Windows systems.

CMake is driven by scripts in CMakeLists.txt files, usually contained in the root and relevant sub-directories directories of the project you are building. The language of a CMakeLists.txt file may seem a little foreign at first but is a powerful way of expressing the build process.

The default way of building a CMake project usually looks something like:

1
2
3
4

ProjectDir$ mkdir build
ProjectDir$ cd build
ProjectDir/build$ cmake ..
ProjectDir/build$ make

There is an interesting Hunter package manager which is aimed at making CMake package management easier. I decided not to include Hunter as a separate build system because of the similarities, but it definitely shows promise when it comes to making CMake easier to use!

For more information on CMake, see the dedicated CMake section of mbedded.ninja.

Conan

• Website: https://conan.io/
• Code: https://github.com/conan-io/conan
• Slogan: Conan.io - The open-source C/C++ package manager

Conan is solely a C/C++ package manager, although it provides interfaces to common build tools such as CMake (this seems to be popular pairing). Installation can be as simple as $ pip install conan.

Conan is tightly integrated with official and community repositories which house popular packages. The official repository is on bintray. It also uses a local repository (or cache) which is used to prevent multiple copies of the same dependency, and for local/private package development.

When used with CMake, Conan can take over the responsibility of what is traditionally CMake’s install/export steps. The install/export steps have always been a difficult issue with CMake, which requires complex logic to produce a relocatable, re-usable upstream CMake package.

Makefiles

• Website: https://www.gnu.org/software/make/
• Code: http://savannah.gnu.org/projects/make/
• Slogan: ???

No. No. No. Please don’t consider raw makefiles as your build system unless you absolutely have to. Did I mention this comparison was opinionated?

Scons

• Website: https://scons.org/
• Code: https://github.com/SCons/scons
• Slogan: A software construction tool.

SCons is a build tool, with no real package management features. The technical limitations of SCons starts to make the scripts complex when it comes to local builds with multiple dependencies and local install paths.

Examples

I tried to do the following for each build system:

• Compile source code into a executable
• Link a third-party library
• Install static library (lib file and headers) and executable onto system
• Run the executable to make sure it works

The minimal code for each platform to do the above can be found at https://github.com/gbmhunter/CppBuildSystemReview.

Each sub-directory contains an example for each build system. Each of these sub-directories also contains a bash script you can run for a one-click demo of the build and run process (have a look at the build script to see how it’s done!).