cmake vs waf: mainly for c++ windows/linux and android

Question

After searching a lot and reading a lot of information, I cannot decide which tool I should use for compiling my code. My codebase is mainly c++. I use primarily linux as my development machine.

Based on opinions I read before, my final candidates are waf and cmake, but I cannot decide myself which one should be more appropiate.

My primary requirements are:

1. Must be able to compile software in windows/linux and android.
2. Must be ready to run tests.
3. Must be able to play nicely with other libraries that must be compiled with another build system but most likely will have to be compiled from source.
4. Must be able to add custom steps, like for example, generating some data from some files (mainly graphics) before compiling, all integrated in the build system.

Some strong preferences are:

1. Being ready to support MAC compilation.
2. Being able to cross-compile from linux as many platforms as I can (maybe windows/linux/android but cannot MAC?)
3. Being able to add support for iOS compilation if the need arises.
4. Would be nice if the invocation interface was similar to that of autotools, since it is the one many people know and it is well documented.

Some questions:

1. If I have some rare requirement, which build system would be more ready to be extended?
2. Are both currently well maintained? (I wonder about waf mainly).
3. Community: if I find a problem, both communities are big enough to support me, in your experience?

For now my feeling is that I favour waf a bit as a tool, but cmake seems to have been quite successful for whatever reason.

Answer 1

WAF

• is pure Python
• becomes part of your project, i.e. no external dependency
• supports many build tools
• can be used to do all kind of automations, not just building

It works perfectly for Linux, Mac or Windows.

On Android, gradle is the chosen build tool of Google. To use that is wise, because it is set up to work by Google. You can call waf from gradle and vice-versa, though.

If you want to learn all the low level Android SDK tools, you could also use WAF directly.

The SDK has

• javac for Android Runtime (formerly Dalvik), Android\'s JVM, and produces a .class file
• jar can also be used for Android
• d8 (formerly dx) produces .dex files, with Dalvik executable code
• aapt2 can then produce the .apk

javac and jar are known to WAF. For dx and aapt2 you would need to create your own tasks, which is very easy.

You would best make a WAF tool and share it. Tools are either part of WAF or there is waftools. There are also these Steinwurf tools.

If you make Android native code using NDK:

• you use CLANG, which is known to WAF

Further on you mentioned requirements:

• WAF has waf_unit_test
• WAF can do gnu_cross compilation. The Gnu toolchain knowns many targets. But for Android you would need to set things up yourself using the SDK or NDK. For NDK you could use the Gnu toolchain.
• You would do waf configure, waf build instead of configure, make, but you could wrap a Configure or Makefile around waf to have the same commands.
• WAF is very easily extendible with Python
• WAF is now on gitlab and constantly worked on.
• The community is surely smaller than for CMake. But it is Python. You can look into it and find out for yourself. You can also contribute and become part of the community.

Answer 2

Don't know much about waf, but CMake fits your requirements pretty well. I do know waf is written in Python, my personal favourite programming language ATM.

My primary requirements are:

Must be able to compile software in windows/linux and android.

CMake does Windows and Linux very well but so does any other build system worth its salt. Someone wrote some Android scripts for CMake. Can't find anything similar for waf (my Google-fu turns up nothing.)

Must be ready to run tests.

CMake has a sibling testing framework.

Must be able to play nicely with other libraries that must be compiled with another build system but most likely will have to be compiled from source.

CMake has good integration with pkg-config, and can link against arbitrary shared libraries.

Must be able to add custom steps, like for example, generating some data from some files (mainly graphics) before compiling, all integrated in the build system.

CMake can generate custom rules.

Some strong preferences are:

Being ready to support MAC compilation.

CMake supports Mac quite well. It will even make you an Xcode project if you want, but it can also do command line builds.

Being able to cross-compile from linux as many platforms as I can (maybe windows/linux/android but cannot MAC?)

Cross-compiling is supported in CMake. CMake will not be the primary source of pain with cross-compiling - literally everything else will.

Especially with regards to cross-compiling for Mac. It's possible, but not worth it to cross-compile for that platform, considering you need access to a Mac anyways to get the libraries and header files, you need to patch GCC and clang and LLVM, etc. The only sound reason I've heard for going through this much pain is running an automated build server. Anyways, if you get a working Linux -> Mac toolchain, you should be able to cross-compile with CMake as if it were any other Unix platform.

Being able to add support for iOS compilation if the need arises.

iOS cross-compilation can be done, but you need a Mac.

Would be nice if the invocation interface was similar to that of autotools, since it is the one many people know and it is well documented.

Write a configure script that just calls CMake (cmake .). Then your users can do a ./configure && make && make install on platforms where that makes sense. There's also CPack which lets you generate DEB, RPM, NSIS (Windows) and DMG (Mac) installers/packages.

Some questions:

If I have some rare requirement, which build system would be more ready to be extended?

CMake is very extensible. It can be extended to support new languages and target platforms. (Given that waf is written in Python, it's going to be pretty hackable too.)

Are both currently well maintained? (I wonder about waf mainly).

CMake is mature and well-maintained.

Community: if I find a problem, both communities are big enough to support me, in your experience?

The community and extensions available are what keeps me coming back to CMake, from things like bakefile, honestly.