And yet, meson just routinely doesn't work. Sure: if you are just trying to do some trivial local compile job it seems fine, but it keeps having issues with even trivial cross compilation cases (which are used even on Linux as you generally want to do a Linux-to-Linux cross compile to control your glibc target) and linker detection (as it is assuming way too much direct control over the linker that it should frankly be delegating to the compiler) that make you have to jump through ridiculous hurdles to make things compile (and that's assuming you aren't on one of the commonly-deployed semi-recent versions of meson where it is a truly lost cause). In contrast, autotools always works: I have never had a blocking or serious issue compiling something that uses autotools, no matter how complex the scenario.

Here are a couple issues I have run into (one being fixed, though too late for some key versions of Ubuntu; and the other just languishing, as I guess "working" is asking for too much).

https://github.com/mesonbuild/meson/issues/6057

https://github.com/mesonbuild/meson/issues/6662

For the second, https://github.com/mesonbuild/meson/issues/6662#issuecomment... is the right solution and I will try to have it documented. Unfortunately, clang disagrees that it's the right solution and meson might have to hack something around that disagreement.

Thanks for the report!

Hum... Configure routinely doesn't work for me either, on even more trivial scenarios than cross-compilation.

When I care to look how to fix it, it's almost always some error on the autotools configuration and I can edit the Makefile to run things correctly. Also, when it breaks, there are normally more broken things on the project. But autotools are always among the first things to break.

Is autotools the first to break or the first that you notice and fix ;)

It is a very good predictor of breakage anywhere. Code where the autotools are perfectly configured normally is very close to correct.

It's usually not broken on my own code because I will write a DAG builder in bare C before I use them personally, so I don't know the breakage timing.

Could be; I'm not an evangelist for meson and if it doesn't work for cross compilation I'd use something else, likely cmake. I don't cross compile very often, so for me it works great. I have run into sadness with meson subprojects, but I'm unconvinced they are a big win.

The problem is that I don't get to make the decision to use meson or cmake: you make that decision when you develop your project around meson; which ties back to the point of this thread: as a user attempting to compile something (which FWIW should essentially always be a cross compile... a native compile is essentially never what you want as it bleeds way too much random machine state into your build), autotools is still king (and certainly much better than the haphazard piles of programmable cmake that people tend to throw together when they use cmake; at least with cmake,npeople tend to develop stuff where I just give up on their compilation scripts and compile all their code with my own replacement scripts... sadly, I haven't managed to do that reasonably for glib yet so I could avoid their meson hell).

For us(https://buildroot.org/) cross compiling with meson tends to be significantly more reliable than autotools already as it tends to be much better at separating host/target artifact builds within a project and setting up the toolchain correctly, autotools tends to need lots of package specific hacks in my experience.

We have a fairly customized integration(https://github.com/buildroot/buildroot/blob/master/package/p...) which we've iterated on for a while that works quite well these days. The cross compilation support with upstream meson has improved a lot over the years and while it's quite mature now IMO it still takes a bit of env setup to work correctly(but once it works it tends to not break much).

I'm not very familiar with meson. I can use cmake to build a project but I don't know how to find various build options without searching through that project's documentation. I probably haven't explored cmake enough.

In the build directory, "ccmake ." Note the "." I need to do this in almost every cmake project I don't know well. Also toggle on the advanced options listing. Occasionally you'll see stuff in the CMakeLists.txt files that don't show up in that menu. This is usually variables you can set on the command line to influence configuration. People are nowadays calming down their desire to program up their own flavor of a gigantic build system, and sticking to simpler idioms. That's a big improvement. However there's a lot of legacy nightmare cmake out there. Meson is much harder to build different dialects. Some people don't like this. After 35 years of build systems, I say yes please!

I forget what I do in meson. Which means I just read the meson.build and meson_options.txt. They are quite straightforward, and very concise, if you're not Doing It Wrong.

Use cmake-gui and it lists all the options for you. Or for the manual method, search in the project's cmake sources for lines starting with "option(".

I would argue this confirms what the OP said cmake is really not very friendly to the user (not developer). Reading through the cmake sources for options is equivalent to "read the source".

But you only have to do this if you don't want to run an actual GUI or ncurses UI which does this for you for some reason ? What would you suggest instead ?

Why do I need to run a gui or ncurses UI if I just want to do the equivalent of configure && make && make install?

The equivalent of this is

    cmake -S source_folder -B build_folder 
    cmake --build build_folder
    cmake --install build_folder

You don't need to run a GUI at all for this, I don't see how you could infer this from the previous messages

Something like 'cmake --list-options CMakeLists.txt' seems the most obvious.

I don't think it would be meaningfully different from what you would get by doing

    less CMakeCache.txt

Listing the options cannot be done by just introspecting a CMakeLists: what would it show for:

    if(FOO)
      option(ENABLE_BAMBOOZLE_${FOO} "Enable Bamboozle - ${FOO}-specific version" OFF)
    else()
      option(ENABLE_BAMBOOZLE "Enable Bamboozle" ON)
    endif()

(and if your meta-build system does not allow to do that, I'm sorry but I'll have to build a meta-meta-build-system on top of it which implements it and no one will like it)

> it's just no comparison to debugging the 1000s of lines of shell code autotools generates

If you find yourself debugging generated scripts, you have done something wrong.

Not really - from my experience autotools can’t really be expected to work properly on any system it wasn’t tested on. And it’s way easier to hack the generated script - usually just commenting out the problematic part, as almost none of those scripts generated by autoconf serve any purpose.

I agree, but I have done things wrong with autotools, then spent hours debugging the generated scripts to figure out what I did wrong.

meson is so nice to use.