Why is there no Makefile backend?

[milobanks]

Is there any reason why Meson doesn't support Makefiles (e.g. it goes against a strict design philosophy)? If there's not, and no one's gotten around to it, I'd like to submit a pull request implementing a Makefile backend. I would much prefer to use Ninja, but sometimes Make is unavoidable.

Really don't want to have to switch to CMake just for Makefile support!

Sorry, no idea why there is a duplicate discussion.

[eli-schwartz]

If we did generate a Makefile, it would have some requirements:

• must not use recursive Make
• must not use pattern rules
• must not use builtin variables

So we would need to use MAKEFLAGS = --no-builtin-rules --no-builtin-variables (these define slow junk we don't use and don't rely on), and then map the existing ninja build edges as Makefile rules.

But, you'd have a Makefile that is only as good as build.ninja, except slower because ninja is heavily optimized for speed in return for sacrificing all the Makefile features we don't use anyway.

So this leads to the question...

I would much prefer to use Ninja, but sometimes Make is unavoidable.

When is it unavoidable? ninja is pretty portable, and there's a POSIX rewrite of ninja in c99 that is even more portable and easier to build. In the worst case, you could almost certainly just build samurai first, and then run meson && samu.

[eli-schwartz]

At the same time you closed the issue and created a discussion, I clicked the "convert to discussion" button, sorry.

[jpakkane]

This is mentioned in the FAQ.

[jpakkane]

And just so there is no doubt:

Meson will not have a Make backend. Even if someone implemented one and submitted it as a PR it would not be merged.

[keithbowes]

I'd personally prefer it to generate a Makefile; they're a POSIX standard, are easy to write and debug, and behave better with existing tools than ninja. Make might be slightly slower, but ninja is hardly blazing-fast. I'll have to search if someone has taken the time to write a conversion tool.

[milobanks]

From Ninja to Make? I looked and couldn't find anything... Samurai, an alternate implementation of Ninja, is pretty basic. You might be able to swap out the graph executor with something that generates POSIX Makefiles.

[eli-schwartz]

The only thing I'm aware of in this area is https://github.com/google/kati which converts Makefiles to ninja files. "For speed purposes", as it turns out.

[jhgorse]

From Ninja to Make? I looked and couldn't find anything... Samurai, an alternate implementation of Ninja, is pretty basic. You might be able to swap out the graph executor with something that generates POSIX Makefiles.

GPT does a decent 90% job of this. It is one of the primary use cases for https://cursor.sh/ a VS Code IDE: converting code from one language to another with the inline edit-replace function. An onboarding example is included which demonstrates the feature upon first launch.

Samurai does not appear to have tests.

A quick test of ckati reveals that it does not work for Makefiles with vpath.

If you read Evan Martin on Ninja, https://neugierig.org/software/blog/2020/05/ninja.html
it is clear that he had zero intention for small projects. I set up Ninja for some small test cases and generally struggled to reproduce the test cases of Evan Jones's properly behaving Makefile, https://www.evanjones.ca/makefile-dependencies.html

I have found that the addition of Makefile generators further complicates things.

Cheers,
Joe

[milobanks]

Do you have any personal experience with transpiling Ninja -> Makefiles this way? It seems like 90% is way too low of a figure for anything useful to come out of it, but I could be wrong.

[jhgorse]

Yes. The 10% that's missing is the proper dependency tracking, which is shown by Evan Jones for Makefiles. GPT4 usually writes a script that works.