Make, CMake, and Meson: A Journey Through Build Systems

October 15, 2024

As a developer who’s always striving to optimize my workflow (remember my love for K3s and Svelte?), I’ve experimented with various build systems over the years. Today, I want to take you on a journey through three significant players in the build system world: Make, CMake, and my personal favorite, Meson. Let’s explore how these tools have evolved and why I’ve come to prefer Meson for many of my projects.

Make: The Grandfather of Build Systems

Make, created in 1976, is one of the oldest and most widely used build systems. It’s a tool that automatically builds executable programs and libraries from source code by reading files called Makefiles.

Pros of Make:

Widely supported and understood
Flexible and powerful for simple to moderately complex projects
Available on almost every Unix-like system

Cons of Make:

Syntax can be cryptic and error-prone
Limited built-in functions
Doesn’t scale well for very large projects

Here’s a simple Makefile example:

CC=gcc
CFLAGS=-I.

hello: hello.o
    $(CC) -o hello hello.o

hello.o: hello.c
    $(CC) -c -o hello.o hello.c $(CFLAGS)

clean:
    rm -f *.o hello

CMake: The Cross-Platform Solution

CMake, introduced in 2000, aimed to address some of Make’s limitations, particularly in managing complex, cross-platform projects.

Pros of CMake:

Cross-platform support
Generates native build files for different systems
More powerful and flexible than Make for complex projects

Cons of CMake:

Steeper learning curve
Can be verbose for simple projects
Syntax can still be confusing for beginners

Here’s a basic CMakeLists.txt file:

cmake_minimum_required(VERSION 3.10)
project(HelloWorld)

add_executable(hello hello.c)

Meson: The Modern Approach

Meson, first released in 2013, is the newest of the three and has quickly gained popularity, especially in the GNOME ecosystem and with Red Hat.

Pros of Meson:

Fast build times
Clear, easy-to-read syntax
Excellent cross-compilation support
Built-in support for modern development practices

Cons of Meson:

Younger ecosystem, so fewer third-party modules compared to CMake
May require more setup for very specialized build requirements

Here’s a simple Meson build file (meson.build):

project('hello', 'c')
executable('hello', 'hello.c')

Why I Prefer Meson

As someone who values efficiency and clarity (just look at my infrastructure setup with K3s!), Meson has become my go-to build system for several reasons:

Speed: Meson is designed to be fast, which is crucial when working on larger projects.
Clarity: The syntax is straightforward and easy to read, making it simpler to maintain build files.
Modern Features: It has built-in support for things like unit testing, which aligns well with my development practices.
GNOME and Red Hat Usage: As a fan of open-source software, I appreciate that major projects like GNOME and companies like Red Hat are adopting Meson.

Here’s a more complex Meson example that showcases some of its features:

project('myproject', 'cpp',
  version : '0.1',
  default_options : ['warning_level=3', 'cpp_std=c++14'])

gtest = dependency('gtest', main : true, required : false)
gmock = dependency('gmock', required : false)

src = ['main.cpp', 'foo.cpp']
exe = executable('myexe', src,
  install : true)

if gtest.found() and gmock.found()
  test('mytest', executable('mytest', 'test.cpp',
    dependencies : [gtest, gmock]))
endif

This example sets up a C++ project, handles dependencies, builds an executable, and sets up a test if the required testing libraries are found.

Integrating Meson with My Workflow

In my projects, especially those involving C or C++ (like some low-level components I use in my K3s setup), Meson has become an integral part of my workflow. Its speed and clarity allow me to focus more on writing code and less on managing the build process.

For instance, when I’m working on a project that needs to interface with my Kubernetes cluster, I might use Meson to build a small C++ application that monitors system resources. The clear syntax of Meson makes it easy for me to set up the build process, manage dependencies, and even set up tests.

Conclusion

While Make and CMake have their places and are still widely used, Meson represents a more modern approach to build systems. Its adoption by projects like GNOME and companies like Red Hat is a testament to its effectiveness and potential longevity.

For me, Meson fits perfectly into my development philosophy of using efficient, clear, and modern tools. Whether I’m working on a small utility for my K3s cluster or a larger C++ project, Meson provides the speed and flexibility I need.

What about you? Have you tried Meson? Or do you prefer Make or CMake? Let me know your thoughts and experiences in the comments below!

In

low