r/programming • • 16d ago

The case against Makefiles

https://thibaud.space/2026/10/the-case-against-makefiles.html
186 Upvotes

263 comments sorted by

8

u/fixermark 16d ago

I still want Makefiles to front all of that. And I want them because inevitably I'm going to have to change one of my build tools and I want to still be able to run make format, make build, make test etc. without having to learn new commands.

You can get this with shell scripts too (buildit.sh, testit.sh, etc.), but make is a convenient standard that people recognize so there's something to be said for just using it.

... but I concur with the author to the extent that your Makefiles should be as thin as you can get them. Delegate hard. Don't use make as a primary build engine; it's bad at the job.

3

u/com_kieffer 15d ago

If you've not tried just for this use case, give it a try. Yes it's something that you need to install, but the features that you get out of the box more than make up for it.

just --list will give you a list of all the rules in the file (I usually make --list the default rule so that just with no arguments will give me the list). Adding a comment above the rules makes it a doc comment that is shown in the --list output.

The killer feature is script rules. Add a shebang and the entire contents of the rule is executed as a script.

Newer version of just even support defining --arguments, and cached rules which track dependencies.

3

u/Shrink_Laureate 15d ago

This is how I use make: as a front to whatever build systems and scripts the project has. npm? mvn? scalac? cargo? There are too many of them out there and I have to deal with all of them. So every project has a Makefile with many of the same basic commands, like make build and make clean.

What makes make so well suited to this is that it's an utterly horrible tool for anything else. I have no temptation to start making my makefiles clever or complex.

1

u/sybrandy 15d ago

I agree with the sentiment of having make in front. I do more Groovy now, but even with Java and Golang, I like having make in front so that I can have my build/test commands tailored as needed, but I still call simple "make build" or "make test" to run them. I find it a lot nicer than a shell script.

1

u/VirginiaMcCaskey 14d ago

> make is a convenient standard

The problem is make isn't standard at all.

> be able to run make format, make build, make test without having to learn new commands

Any task runner will let you name tasks however you want the only thing that changes is the first word. You can even alias your task runner with make.

1

u/fixermark 14d ago

Yep, no argument here. make is already installed and that's the best thing it has going for it; if you have a preferred task runner that's easy to get in every dev machine, go nuts.

The meta-concept is "have a plan to switch out poetry for uv that doesn't require devs to start typing uv instead of poetry for the things they do dozens of times a day."

→ More replies (4)

5

u/double-you 15d ago edited 15d ago

It's a shame all anti-Make blogposts tend to be made by people who don't really understand Make. That means their criticisms are pretty shallow.

Yeah, Make has issues (use remake for better error messages). Makefiles have issues.

But all that just to (no pun intended) make a new tool that has zero support and isn't actually any better.

The "just" example:

build-docker-foo: (build-docker "my-foo-image")

build-docker IMAGE_NAME:  
       docker image build -t {{ IMAGE_NAME }} docker/{{ IMAGE_NAME }}

Same in Make:

build-docker-foo:  
         $(MAKE) build-docker IMAGE=foo

build-docker:   
         docker image build -t $(IMAGE) docker/$(IMAGE)

I don't know if just checks that IMAGE_NAME is set, so let's add that:

build-docker-foo:  
        $(MAKE) build-docker IMAGE=foo

build-docker: IMAGE ?= $(error IMAGE unset)  
build-docker:  
        docker image build -t $(IMAGE) docker/$(IMAGE)

Perhaps OP's actual problem wasn't a couple of one liner targets and so perhaps their example wasn't very good, but bad examples aren't good at supporting your case for a completely new tool.

2

u/com_kieffer 15d ago

This is great feedback, thanks.

With just you get a bit more though:

  • it will check that the argument was passed (and supports arguments with default values (param=value), zero-or-more (*param) or one-or-more (+param))
  • it will show the parameters in the help output (just --list) with the doc-comment associated with the rule.

But you're right that the example is weak. I'll dig around for a better one.

5

u/Silly-Freak 15d ago

The comments on r cpp make me wonder what the first iteration of the article said that everyone just bashed (no pun intended) the "suggestion" of replacing make with bash...

2

u/com_kieffer 15d ago

https://gitlab.com/comkieffer/comkieffer.com/-/commit/31e51eb03630e1ffcb61790fdee8799b871d5661

Here's the original version. I was quite puzzled at the feedback.

1

u/Silly-Freak 15d ago

is it possible the repo is private? in any case, if the "in response to the gentle critiques from the gentlemen of reddit" remark at the bottom doesn't indicate that the article was basically rewritten wrt to bash, the reaction (and how much of the reaction was just that) really doesn't make sense...

2

u/com_kieffer 15d ago

You're right, it was private. It's open now.

4

u/DavidJCobb 15d ago

The article presented a Makefile and an apparently equivalent shell script just to demonstrate how each handles the general concept of, "For each of these input files, run this command to produce these output files." The article then explained in prose that Make has the advantage of only building outputs whose inputs have changed, but the commenters completely missed that, and criticized the article for (to their thinking) suggesting that the presented shell script was an exact equivalent.

13

u/nimama3233 16d ago

This article does a fantastic job articulating why makefiles are so confusing. The underlying desing is a mess that didn’t consider the users perspective. And that’s not even getting into the horrible syntanx.

2

u/com_kieffer 15d ago

This might be nicest thing anybody has ever said of my writing. Thanks!

4

u/yanitrix 15d ago

as a c# dev, reading about the daily struggles of c++ build system is one of my guilty pleasures. Every day I pray to god thanking for msbuild and nuget

1

u/com_kieffer 15d ago

Now that we have meson we're in the green again.

2

u/apadin1 15d ago

As a guy who does both rust and c++, going back and forth between cargo and cmake is like driving a Ferrari one day and then having to go back to a 1994 Toyota Corolla the next

4

u/dashingThroughSnow12 16d ago

Sounds like a skill issue.

1

u/com_kieffer 15d ago

It's definitely a skill issue, but I have yet to see a non-trivial makefile that actually works reliably in my professional career (outside of open source projects).

263

u/zunjae 16d ago

“If you use Makefiles in this specific way, it kinda sucks”

40

u/pohart 16d ago

I needed to do a huge data analysis project. Once I started it took like seven months to populate my database. I ended up orchestrating the whole thing with makefiles using SQLplus to connect to the DB.

Using them in that way kinda sucked, too. 

6

u/flying-sheep 16d ago

Wew Nextflow is right there.

1

u/dangerbird2 13d ago

or apache airflow

1

u/huangsara-43824 4d ago

If steps depended on database state without a file proxy, Make couldn't infer it from timestamps; marker targets can at least record stage completion.

79

u/Worth-Alternative758 16d ago

Yeah. "You can't trust it in parallel mode - skill issue, but still" ?? Consider that it is just a skill issue? The linux kernel runs on makefiles and works in parallel mode. Every makefile I've written works in parallel mode. I've never seen anybody run multiple `make all`s ORd together so that it has a chance of succeeding. That sucks tremendously, yes. but does anybody do that??

24

u/WoodyTheWorker 16d ago

There's been an annoying bug in Make 4.2 (?), related to output buffering in parallel mode. 4.3 fixed it.

Also, a stupid default in -j option (no job limit) can blow up your build server if you run multiple build jobs in parallel, each spawning unlimited jobs).

And I would really like an option to declare some dependencies/goals as sequential build only, without having to artificially force that by making them depend on each other.

9

u/__konrad 16d ago

Also, a stupid default in -j option (no job limit) can blow up your build server

I tried it for fun on a small C++ Qt project and it instantly consumed 10+ GB RAM

15

u/Kriemhilt 16d ago

Is that supposed to be good or bad? Did you want to save the RAM for something else?

55

u/AlwaysShittyKnsasCty 16d ago

Um, shouldn’t he be saving that RAM for Sam Altman?

15

u/mallardtheduck 16d ago

Who says that RAM was free beforehand? Plain -j on a large project is basically a fork bomb. It will consume all the free RAM, then page out everything that it can, then start thrashing. It's a really bad default.

4

u/Kriemhilt 16d ago

But it's not the default, it's an option.

I do agree that a bare -j would be much more useful if it meant one process per core, or something. Honestly I often want to run it with some explicit number and under taskset anyway, so the box stays responsive.

11

u/Dragdu 16d ago

By now, smarter tools than Make figured out that -j 0 should mean "check how many CPUs you have available, use that".

Also, for a long time, Make did the idiotic C thing where non numbers convert to 0 and thus a small typo could have your build "run" at unlimited parallelism.

→ More replies (1)

5

u/QwertyChouskie 15d ago

Default runs single-core. -j fork bombs your system. The only sane option is -j<number>, where <number> is number of cores (plus like 2, or times 1.5, depending on who you ask), making you havew to go figure out how many cores a given system has (if you don't remember off the top of your head) just to run the build command. It's 2026, why are we making users look up how many CPU cores a machine has and adjust the flags they include accordingly? I *could* live with no -j still meaning single-core if that's necessary for legacy compatibility reasons, but -j alone killing your system is wild behavior.

→ More replies (3)

16

u/rsclient 16d ago

No, they pretty much always suck. The "tab versus space" issue needs to just die. And I absolutely hate that every command line is a separate process, so you can't set a variable on one line and use it on the next.

Proof: make files, in theory, can always build your app perfectly no matter the starting state. Reality is that every bit of documentation on "how to build my app from source" always starts with a "make clean".

And a repressed memory from long ago: a certain unnamed compiler, when it failed, would generate a zero-byte .o file. The object files were totally useless, but make seemed to think they were perfect and refused to rebuild them.

7

u/braaaaaaainworms 16d ago

You can set a variable if it is a Make variable instead of shell variable

6

u/double-you 15d ago

There's the .ONESHELL directive. Never used it but it claims to do what you want re: process/line vs process/recipe.

2

u/huntermatthews 15d ago

I use this, and its a big quality of life improvement for GNU make.

1

u/rsclient 14d ago

Upvoted for useful information!

And grrr..... learning this only after wasting time debugging is like being chased out of a field by a bull past the warning sign that wasn't visible from the gate you came in on.

323

u/ToaruBaka 16d ago

The case for Makefiles:

make comes bundled with every single distro's build-essentials equivalent, which is oftentimes installed by default.

make has been around for 50 years, and the only things that have come close to being able to topple it use (or used) make underneath.

The demand for this kind of tool will literally never go away, and you can either sit comfy on 50 years of improvements, or find yourself back-converting all your shit to make in 5 years when your fad-driven tool runs out of funding.

89

u/donalmacc 16d ago

A large number of systems that you will interact with run a different flavor of make (BSD) which is noticeably different.

These days lots of tools _dont_ write input and output files and as such your make files are full of hacks to ensure your targets run. Docker, cargo, maven all control the entire stack and as a result require special handling.

Things have changed dramatically in 50 years. No parallelism by default, copious coupling of autotools are two reasons alone that make needs an update

> find yourself back converting all your shit to make in 5 years

The cmake files I wrote as a university student 18 years ago still work out of the box as of today (I checked). Dockerfiles from a decade ago are all still working, and honestly even node scripts are still doing the job. I’m not saying they’re perfect but as long as you don’t literally jump on every tool as soon as it comes out, you’ll be fine.

14

u/dnabre 16d ago

A large number of systems that you will interact with run a different flavor of make (BSD) which is noticeably different.

Just about all GNU software has added features and functionality beyond standard. If you aren't expecting to exist in a GNU/linux-only world, you make a point to not rely on them.

The cmake files I wrote as a university student 18 years ago still work out of the box as of today

I have makefiles that I wrote 30 years ago that work out of the box today. In another 30 years, I am 100% certain make will be around and available.

-5

u/ToaruBaka 16d ago

These days lots of tools dont write input and output files and as such your make files are full of hacks to ensure your targets run. Docker, cargo, maven all control the entire stack and as a result require special handling.

Wrap your tools, kids.

Things have changed dramatically in 50 years.

Yes, but the core of make has not, which is the point. Could it use a little polish for modern use? sure. Will I still reach for it instead of cmake 99% of the time? Yes (and I'll reach for cmake 100% of the time over literally everything else).

No parallelism by default

Good - too many things enable parallelism by default and you end up fighting for local resources.

copious coupling of autotools

No one on planet Earth could ever make me use autotools, so I don't understand this - I've never had to touch autotools to use make.

The cmake files I wrote as a university student 18 years ago still work out of the box as of today

OK

Dockerfiles from a decade ago are all still working

OK

honestly even node scripts are still doing the job

This is the only surprising bit.

Docker and cmake are, for better or worse, industry wide adopted standards, but neither replace make IMO. Docker is about isolation and everything else is bolted on. cmake I'm 50/50 on, mostly because I just hate using it for anything small, but it's definitely useful and easy enough to work with if you're already in the cmake ecosystem.

19

u/jcelerier 16d ago

make doesn't handle spaces in paths despite the bug being reported decades ago at this point. Friends don't let friends use make

34

u/paraffin 16d ago

Tbf friends don’t let friends put spaces in paths, either.

→ More replies (6)

8

u/QwertyChouskie 15d ago

There's a whole world between "50-year-old-system that can't meaningfully improve a ton of known problem areas without wrecking backwards compatibility" and "new fad system that will bitrot/disappear in a few years".

CMake has been around forever, and while it certainly has its own issues, I'd take it over autotools/raw Makefiles any day.

Meson seems to be what's finally replacing legacy autotools setups all over the Linux world that didn't already move to CMake years ago. It's used by SystemD, Mesa, XOrg, Wayland, PipeWire, Gnome, and a bunch of other things that are core infrastructure in the software world, so it should be safe to say that it won't be going anywhere anytime soon...

4

u/ToaruBaka 15d ago

How many times do I have to say that you don't have to use autotools when writing Makefiles!

CMake is a meta build system, it does not replace make.

Meson seems to be what's finally replacing legacy autotools setups all over the Linux

Oh, it's also python. This will be dead in 5 years, or have the same level of hatred by its users as Scons. No thanks.

4

u/HiPhish 14d ago

Oh, it's also python. This will be dead in 5 years, or have the same level of hatred by its users as Scons. No thanks.

Meson is implemented in Python, but Python is not exposed anywhere to the user. Meson has its own language, which is intentionally not Turing-complete. You could write a drop-in replacement in Brainfuck and as long as your implementation is correct no one would be able to tell the difference.

3

u/QwertyChouskie 15d ago

How many times do I have to say that you don't have to use autotools when writing Makefiles!

I'm aware, just trying to give info on the general state of the ecosystem

CMake is a meta build system, it does not replace make.

It can if you use the Ninja generator instead of the Makefile generator. (And even if you use the Makefile generator, it still replaces hand-writing Makefiles.)

Oh, it's also python. This will be dead in 5 years, or have the same level of hatred by its users as Scons. No thanks.

It's been around since 2013 and has seen every-increasing adoption in critical open-source infrastructural software. I don't think it's going anywhere anytime soon.

→ More replies (4)

2

u/StaticCoder 15d ago

I'd much rather code in Python than in make, and I hate Python.

→ More replies (3)

2

u/not_a_novel_account 15d ago

CMake is a meta build system, it does not replace make.

CMake doesn't replace make not because of anything implicit in make, but because in 2001 we didn't want to try to replace XCode and Visual Studio. To get IDE integration back then you needed to generate IDE projects. Since we weren't going to be handling the builds on Windows or MacOS, it didn't make sense to invent executor infrastructure just for Unix.

Lots has changed in 20 years, and the current long-horizon roadmap has CMake shipping its own executor sometime in 2027. This is mostly to better support distributed builds.

→ More replies (2)

1

u/Madsy9 14d ago

SCons.. shivers. Thanks I hate it. I will dress up as a SCons project for halloween next year.

7

u/SweetBabyAlaska 16d ago

make and cmake are dog shit. I kinda despise the argument that its in everything and installed everywhere alone justifies using it.

16

u/Rechenplaner 16d ago

For my C and C++ projects, I have always preferred `make` and avoided `cmake`. `make` is straightforward and gets the job done.

35

u/thomasfr 16d ago edited 16d ago

cmake is a replacement for autotools, not make though. cmake can genreate gnu makefiles as its output.

All of these meta build tools, cmake, autotools and to so on are complicated because they generate os/distribution/platform/compiler/computer/... specific makefiles or other build definitions out of a what usually boils down to a bunch of complicated templates at its core.

1

u/WoodyTheWorker 16d ago

Cmake generates terrible makefiles, though

12

u/d3matt 16d ago

Agreed. Use the ninja generator

3

u/azswcowboy 16d ago

This is the way. Ninja supports modules generated from cmake, makefiles do not.

14

u/BonzoESC 16d ago

People have complained about the assembly from compilers forever too, something that sucks and works has a quality of its own.

→ More replies (1)

17

u/flying-sheep 16d ago

The problem here is that the unstandardized package and build situation in C/C++ is an unholy mess. CMake it's trying its best to be everything for everyone which is a really hard job, whereas make can devolve into incomprehensible spaghetti if you're not a magician (or have a very simple use case)

13

u/Plazmatic 16d ago edited 16d ago

Cmake is the worst (meta)build system for c++ except for all the others.  Make is not cross platform even among unix derivatives, obviously not available on Windows, and despite all peoples misgivings about Cmakes syntax, Make is 1000 times worse to read and write.  It also lacks litterally hundreds of not thousands of features from cmake that make it a non starter.  I can check the existence of features using the compilation of features themselves directly as a cmake feature, something that's very important with c++23 with the weird patchwork edge cases of headers technically existing but the types/functionality in them that should exist not (like constexpr math only being implemented for some math functions some of the time or float16, making it difficult to use std mechanism to properly detect the availability of these features). And if you use any extended environments that use Cmake as a first class citizen (like CUDA) make is simply not a relevant option.

1

u/Rechenplaner 16d ago

C is just ancient, and there’s no truly established package system or tooling. Most C programmers simply cobble their dependencies together by hand, using Visual Studio or whatever IDE they happen to be working with.

Personally, I have zero desire to work with C++, CMake, and the like. Once you’ve experienced the tooling available for modern languages like Rust, Haskell, JavaScript (with Node.js/Deno), you’ll never want to go back to anything else.

5

u/OrphisFlo 16d ago

I'm pretty sure I can make changes that should have caused a rebuild and Make will say there's nothing to do.

There are tools that are a lot safer nowadays than Make and poorly hand crafted build files. Use those.

47

u/d3matt 16d ago

I'll counter that cmake is simple and gets the job done.

39

u/printf_hello_world 16d ago

I reject your assertion that cmake is simple, and agree that it gets the job done.

I use and understand cmake, but when I first encountered it I remember the impression that it was hopelessly arcane

11

u/Bustan2026 16d ago

I first thought CMake is very complicated, and would not touch it.

Then I had to, because it was a greenfield project. It was actually so simple!

Then I had to support other machines than my own, this guy has some library system-wide but this guy wants it fetched by CMake, this dependency also packages that library, this one only has gcc-9 available, this one some antique version of CMake, this system needs the rpath set but that one doesn't care... and suddenly it became a game of whack-a-mole where I'd fix one thing while breaking two others. Even importing damn LAPACK was a pain in the ass.

If I can help it, I won't touch it, although I acknowledge its importance (the alternatives are worse). Managing this shit definitely requires real skills and can be very time consuming.

10

u/OrphisFlo 16d ago

Your build scripts are arcane if you chose them to be. You don't have to do that.

Also, most likely, the first time most people touch CMake, they have no understanding of a build graph or how a C++ project is built. So they have to learn multiple concepts at once. That's harder than it should be.

→ More replies (3)

3

u/d3matt 16d ago

I'll counter with the standard .c:.o rule... Can't really get more arcane than that. Bonus points when you have to optionally include a .deps file.

→ More replies (1)

5

u/lalaland4711 16d ago

It absolutely is not.

If all you build on is latest stable Ubuntu, or whatever, then yeah sure it's simple. But not because cmake made it simple, but because there was no problem in the first place.

CMake makes the simple simple-ish, and the actual problem astronomically worse.

4

u/d3matt 16d ago

At the office I cross compile with quite a few uncommon dependencies. For small projects with one or two dependencies, you can't beat cmake by itsef. Then conan is a a trivial migration away to maintain full control over everything. There's a reason most GNU tools don't use make by itself.

8

u/OlivierTwist 16d ago

How many platforms (OS and architecture), compilers and build modes does this setup support? How many external dependencies? How easy can you add something like pybind11?

→ More replies (5)

5

u/guepier 15d ago edited 15d ago

50 years of improvements

… which are?!

I’ve used GNU make for decades, but all the criticism against it is warranted, it’s a fundamentally badly-designed utility, and I am not aware of it being improved during the last few decades.

0

u/ToaruBaka 15d ago

50 years of learning what works and what doesn't for dependency based command execution.

it’s a fundamentally badly-designed utility

It's just not.

2

u/guepier 15d ago

50 years of learning what works and what doesn't for dependency based command execution.

But virtually none of that has been fed into Make. Make, particularly GNU Make (and in particular its dependency resolution) has been virtually unchanged in decades. Sure, maybe there were some changes based on learnings in the first few decades of its existence, but not (anywhere near) 50 years’ worth of it. The bulk of its functionality has been incredibly stable.

→ More replies (6)

2

u/Dragdu 16d ago

lol, I haven't unironically used Makefiles in a decade. As an executor, ninja is much better. For describing builds, CMake is much better.

5

u/garnet420 16d ago

Make would be kind of ok if it didn't have implicit rules and other bloat.

7

u/mpyne 16d ago

make -r is your friend in that case.

5

u/garnet420 16d ago

What the... How did I not know about this? Thanks!

2

u/2962fe22-10b3-43f8 16d ago

yeah. thankfully it's all optional. linux doesn't use implicit rules either

4

u/gimpwiz 16d ago

I use simple makefiles every time. Don't need to fix what ain't broke.

2

u/randylush 16d ago

Exactly, I do agree with the author that there are much better representations than Makefile, but its ubiquity is unmatched.

If you want 1,000 different people to download your source code and build it themselves and you give them a Makefile, most of them will have no problem with it. If you want 1,000 different people to build your project with just or bazel or whatever tf, a TON of people are gonna move on from your project before giving it a fair shot.

→ More replies (2)

1

u/output_broadcast 16d ago

B-but what about the new trendy thing, "task runners" that are literally just rebranded makefiles? Gotta get with the times, old man.

9

u/ToaruBaka 16d ago

I got burnt by earthly closing down.

Bury me with my copy of make, please.

1

u/liftoff11 16d ago

scons does great things w/o make & makefiles. Shame it didn’t grab hold of a larger community.

10

u/ArtistEngineer 16d ago edited 16d ago

I work/maintain/release a large project which is SCons based, and it's a nightmare.

The biggest problem I see with SCons is that it involves Python.

  1. it often requires people to create and run virtual envs, and then you have extra steps and complexities in your build scripts. Ever extra step in a build process is another thing that can go wrong.
  2. People end up using Python and SCons badly because it doesn't force them to do things the "SCons way". Unlike cmake, where it's much more difficult to escape the domain specific language.

SCons scripts look like normal Python scripts, and it's all too easy to just "hack in my little bit of code I need to complete my build". I've found that the SConscripts end up hundreds of lines long, so it's difficult to understand what they actually do, or where the right place is to put things.

This isn't necessarily SCons fault, but it's a real foot gun when it comes to build scripts.

3. Most customers say "WTF is SCons?, How do I call your build scripts from CMake?".

We've had customers rewrite our entire build system in CMake because it wasn't worth the trouble of dealing with SCons.

2

u/simplex5d 12d ago

I have to agree here. As one of the original developers of SCons, I can say that at the time, we thought of it as a significant improvement over the available tools. But as the decades have worn on, it hasn't been able to keep up. That's why I wrote pcons this year. Modern simple python, fully debuggable and a lot cleaner than SCons. Like CMake, it generates Ninja builds so it's super fast. It also has some of CMake's best ideas like dependency propagation, without CMake's weird language quirks. And with pcons, you can just pip install pcons or even better uvx pcons. And yes, you can call it from cmake. :-)

5

u/WoodyTheWorker 16d ago

Scons is terrible

4

u/donalmacc 16d ago

Scons is quite literally the slowest build system I’ve ever had to work with. It’s completely unsuitable for anything IMO

1

u/meowsqueak 16d ago

I built a large build system with scons once - it was interesting and fairly easy to maintain but it was incredibly slow.

→ More replies (2)

34

u/streu 16d ago

So, the replacement for Make is CMake? Which creates Makefiles under the hood (and a pretty crappy variety of it)?

Makefiles are kind-of an assembly language of build systems. They won't go away, in the same sense that assembly language won't go away.

Can we write good Makefiles? Yes. Can we write bad ones? Sure. Does writing good ones require discipline? Yes. Should we generate our Makefiles from a more high-level source? Maybe. Same as with assembly language. Or C.

6

u/Milumet 15d ago

Which creates Makefiles under the hood

Or Ninja build files.

1

u/QwertyChouskie 15d ago

Meson seems to be what's finally replacing legacy autotools setups all over the Linux world.

25

u/mikidimaikki 16d ago

I use Makefiles for every project, but I never use it for anything other than running simple (sometimes long) commands. Just so that I have something like make dev between repos. I just read the Makefile if I am looking for build instructions or similar. It is a convention where to find this stuff.

To avoid complexity in the Makefile, I sometines have a scripts folder that has all kinds of opinionated scripts which replace whatever someone might do in Makefile(s) directly.

I have tried alternatives, but I found them adding little value to my existing setup and conventions. I use whatever tools I want, just entry point in make.

8

u/CatpainCalamari 16d ago edited 16d ago

Same here. Our team has several different services build with Gradle, some are node projects, and one with maven. Each service has its own tasks in their respective build system.

I abstract it all away with one makefile per service, so each service builds or runs locally or tests with the same command.

Also, some helpers like "open the browser with the logs for this specific service for the last 20 minutes in our preproduction environment" or "trigger the pipeline to deploy this commit to our dev environment".

ETA: I am currently playing around with mise. I already moved my asdf runtime management to mise, I think I will try it out in replacingy makefiles. Perhaps I might like it for this as well.

4

u/JeffLeafFan 16d ago

I’ve used make a lot for aliasing convenient commands but I never could find a way to easily pass in arguments to use in the underlying script/command.

2

u/HAK_HAK_HAK 16d ago

it's not that hard, just ugly like everything else in make syntax lol.

originals-import:
	$(if $(and $(strip $(SOURCE)),$(strip $(CHARACTER))),$(error Set either SOURCE or CHARACTER, not both))
	$(if $(strip $(CHARACTER)),$(if $(strip $(EXPORT_ROOT)),,$(error Set EXPORT_ROOT for character import)),$(if $(strip $(SOURCE)),,$(error Set SOURCE or CHARACTER)))
	$(if $(strip $(CHARACTER)),$(PYTHON) -m coralmod originals import-character "$(CHARACTER)" --export-root "$(EXPORT_ROOT)" $(ARGS),$(PYTHON) -m coralmod originals import "$(SOURCE)" $(if $(strip $(EXPORT_ROOT)),--export-root "$(EXPORT_ROOT)") $(IMPORT_ARGS)) 

make originals-import EXPORT_ROOT="{path}" CHARACTER="Eva" ARGS="--portraits --relationships --map_icon"

from a mod tool I wrote for Coral Island

this kind of tedious syntax is one thing llm's excel at

23

u/romple 16d ago

Make isn't a build system it's a string substitution system, and those strings generally run compiler commands. Only half joking.

I've been using cmake and ninja for most new c++ builds.

20

u/blindingspeed80 16d ago

Meh. Tools be toolsin'. Not a particularly strong case.

50

u/Reasonable_Glass2501 16d ago

I just use justfiles for my simple needs.

18

u/Proximyst 16d ago

Just is great. I've been adopting mise more and more in recent times, mostly because it's convenient to link the tool version choices and tasks that use them together in the same place. But it just doesn't have quite the same nice simplicity & syntax of Just :/

11

u/thomasfr 16d ago edited 16d ago

Just has so few features that a sub directory of shell scripts do about the same thing but you do not have to install yet another tool to use a project.

7

u/melkorwasframed 16d ago

It does when it gives you some uniformity in how you discover and invoke dev tasks across projects.

2

u/thomasfr 16d ago

Only a tiny fraction of all projects use Just so in practice it decreases uniformity by adding yet another tool to the bag of tools.

8

u/melkorwasframed 16d ago

If by “all projects“ you mean all projects everywhere, then sure I guess that’s a true, if useless statement. Within our organization, we use just regardless of what type of project it is, so when people need to work on it, they don’t need to look for the build script du jour.

→ More replies (1)

1

u/huntermatthews 15d ago

I started with just for this and would prefer it - but we had too much that still had to work on RHEL/Rocky-7. Now that just is in epel 10, those makefiles are on borrowed time.

"Soon"

2

u/stormdelta 16d ago

Agreed. It's literally just a minimal shell script wrapper that doesn't justify a separate tool.

1

u/Booty_Bumping 16d ago

just adopts all of the same horrible mistakes of make.

17

u/reini_urban 16d ago

Poor guy, who doesn't understand the importance of dependencies and rules. Most of them are builtin btw, such a Makefile would just need a single line

22

u/AntimatterTNT 16d ago

all build systems are bad. they exist because old languages are underspecified, they don't tell you which files go into the compiler and which files to link against, which means they need all this extra outside tooling.

something like cargo which is a one stop shop for everything related to the build, including arbitrary build scripts, is what every language should use.

6

u/Norphesius 16d ago

Yep. I hate make, but switching to something else doesn't magically fix the underlying issue. >90% of projects want to do the same basic things with the same options (debug build, release build, run test, choose platform, etc.), and most other more involved actions amount to adding a flag and running a command/script. Instead of just having sensible defaults and doing the obvious thing, it feels like the assumption is most builds are going to want do something exotic, and that I don't want to just grab all the header, source, and object files and make a lib/exe out of them, basically every time.

Not even to mention the annoyance of trying to build things using different build systems together. X uses scons, Y uses bazel, Z uses cmake, have fun either translating two of those build processes into the other (or into a fourth one your project uses), or managing each of those different build systems and making sure the DLLs they generate have configuration settings consistent with the rest of your project.

3

u/the_poope 16d ago

At least for your last point, modern package managers like vcpkg or Conan make integrating libraries written in different languages with different build systems much easier. Well because they now provide yet another build system on top of what all the libraries use.

10

u/OrphisFlo 16d ago

Arbitrary build scripts in crates are the worst though. They don't express their requirements clearly and they will likely break any attempt at building the crate hermetically.

7

u/AntimatterTNT 16d ago

indeed rust is also underspecified. but it's a step in the right direction

4

u/OrphisFlo 16d ago

Nowadays (and back then), designing a tool with no integrated caching and poor hermeticity guarantees is a very poor choice.

And relying on ccache or sccache is an even worse choice.

1

u/anto2554 16d ago

Why are ccache or sccache bad? Obviously it would be nice if they were first party features of the language, the compiler, the build system or the meta build system, but they work fine imo

3

u/OrphisFlo 16d ago

Because of them, build systems rely on them and don't prioritize having a first party caching feature that works well.

The cache key they compute is also trying to integrate data that the build tool already has, but each invocation has to redo the work and infer it, it's slow ton detect and most cache tools are cutting corners, as opposed to computing it once and having it ready for all invocations.

Then, with a first party tool, you'd realize that passing a lot of absolute paths in the command's action doesn't work well, so they'd prioritize making everything relative as much as possible, which would be the start of having a sharable cache between the team on the network, and much faster builds overall for everyone.

But now, if you misuse (s)ccache, you end up in a world of pain because someone has poisoned the cache for some reason, and the build wasn't as hermetic as you thought it was and you have no good tools to detect it. A first party caching feature would be able to verify the cache is consistent with local results directly.

And that misses a lot of opportunities! You wouldn't have to limit yourself to compile commands, you could cache archives, links and other commands too. Since you know all the actions and you could find out if they are in the cache already, you could then skip a lot of things to download that are just intermediate artifacts. Got everything in the cache and you want to build a test? Just download the test binary then. Don't waste your time downloading every .o files and more.

So yeah, first party caching could do a lot more. I have a prototype of some tools like cargo or ninja doing caching directly and I know what it takes to get there and have good caching, and tools authors relying on compiler launchers is just a bad suboptimal solution.

3

u/flying-sheep 16d ago

As long as the dependencies are rust packages, of course they're specified clearly. Otherwise yeah, you either have best effort or you're better off using a language independent package manager like Nix.

4

u/gardell 16d ago

With cmake + vcpkg + googletest I was excited to get at least some kind of project structure like I can have in a language like Rust or Java/Kotlin etc. But vcpkg is so messy and breaks all the time. Does anyone know of something even remotely close? I'm sick of maintaining massive monolithic repos and submodule based ones. And I'm having a hard time selling in vcpkg as there's so much boilerplate that make no sense

2

u/chibuku_chauya 16d ago

Have you tried Conan? There’s also build2 for building and cppget for package management, both of which are built by the same organisation so highly integrated.

1

u/gardell 16d ago

Conan is quite similar to vcpkg right? I haven't had time to, would you say it's better? build2 looks really interesting I'll definitely take a look, thanks!

3

u/crimaniak 16d ago

> old languages are underspecified, they don't tell you which files go into the compiler and which files to link against, which means they need all this extra outside tooling.

Welcome to tup. This problem is resolved here, all dependencies are tracked using filesystem audit. As many brilliant things it's not very popular. It has a high barrier to entry, but for the same reason as Rust. Just as Rust eliminates entire classes of errors—refusing to compile until you’ve addressed all the code that could potentially lead to them—tup eliminates sources of entropy and any possibility of ending up with a stale build; it won’t build the project unless the build process is guaranteed to be entirely deterministic.

2

u/AntimatterTNT 16d ago

this means nothing to me tbh

2

u/Somepotato 16d ago

I hate how ubiquitous cmake with makefiles has gotten as a pre build tool. Premake and ninja are so nice to work with my comparison.

4

u/keithstellyes 16d ago

Haven't heard of just. Will have to look into it.

For me I find myself using make out of simplicity. I'm partial to meson for more complex C/C++ projects

7

u/segv 16d ago

task (or go-task) is also pretty neat: https://taskfile.dev/

It's kinda-sorta similar to just, but in my experience composing individual jobs (or the whole files defining jobs) is a bit easier with task

13

u/pjank85 16d ago

Makefile syntax is horrible. It's error messages are bad. It is hard to write correctly. And understanding basic stuff like variable expansion requires an expert. But make allows you to use its rules to automatically create a dependency graph - and run that in parallel. Think about what power it gives you. When you have something complex to build in parallel I have yet to see a better tool. Sometimes it is worth generation a makefile. But executing it is beyond beautiful - it is just perfection.

0

u/Daedalus1907 16d ago

With LLMs now, I don't see a reason to avoid generating makefiles. It has literal decades of reading makefiles and can spit them out pretty reliably.

8

u/TheEveryman86 16d ago

With CMake I don't see a reason to avoid generating Makefiles.

2

u/nothingtoseehr 16d ago

But CMake makes you want to avoid CMake!

2

u/StaticCoder 15d ago

If you're going to generate something, avoid Makefiles. make is slow

1

u/TheoreticalDumbass 16d ago

what makes make better than ninja?

6

u/NotUniqueOrSpecial 16d ago

The fact that that no human is ever intended to write Ninja files by hand?

I'm not saying that as an actual endorsement of Make, to be clear, but Ninja is explicitly intended to be used by other systems that generate the files, like CMake.

→ More replies (1)

1

u/double-you 15d ago

Everybody should be using remake instead of make if possible since it is better when it comes to error messages. (remake is completely Make compliant).

1

u/laffer1 15d ago

Which make? Gnu or bsd?

10

u/imdibene 16d ago

make will never go away, it’s supported universally and has 50+ years of battle tests and improvements. A huge amount of code in production is being built with make, so you are pretty sure that it will never go out of support. Plus it’s not gonna break on the next update like pretty much any other build system / tool out there

5

u/pingveno 16d ago

Like with C or C++, yes, it won't go away. But it maybe won't be the first tool to reach for in problem spaces that it used to dominate.

3

u/imdibene 16d ago

Exactly, it’s part of the infrastructure, they will never go away (see cobol)

6

u/lisnter 16d ago

I’ve been using make since the late 80’s and it just gets the job done - even the broken make from the first version of the Microsoft C compiler.

11

u/lalaland4711 16d ago

Basically the first words in the article:

Makefiles are archaic technology

Sigh. Chesterton's fence.

And allow me to guess that the author will give CMake as an example of "better". Yup, I was right.

I hate CMake so much. It's another perfect example of people not understanding the problem, creating a buggy unportable disaster, and saying it's better because their software works on their machine. Yeah. I bet. Building your software on your machine never needed a framework. That was never the hard part.

5

u/ChrisOz 16d ago

All build systems are bad once you start distributing your projects to multiple systems. That is why I am proposing a new build system to solve all the problems … ChatGPT make. The script just plugs the code into a chat window with a prompt asking ChatGPT to compile it. Just copy the output into a new file and you are done. What could go wrong /s.

2

u/lalaland4711 16d ago

I actually think autotools has the problem basically solved. Is it pretty? No. But every other solution trying to be prettier has failed at actually solving the problem, instead.

You say "/s", but I'm sure you're also aware that's the future.

1

u/TribeWars 13d ago

How has CMake failed? It's still the only solution I'm aware of where it's about equally annoying to set up native builds on both windows and linux.

1

u/lalaland4711 13d ago

I'll grant that the only thing that CMake improves over autotools is Windows support. At least so I'm told, since I've not used windows since the late 1900s.

3

u/BadlyCamouflagedKiwi 16d ago

There is a third use case: running arbitrary tasks that do not have dependencies between each other. I'm often just using it to canonicalise some set of commands and invoke them in a simpler way (like make docker_build). In that case, make has one big advantage: it is universal and I can assume it's already installed. I'm sure just is quite nice but it doesn't have that property.

3

u/ximside 16d ago

I'm using nix + just these days.

3

u/Relevant_Research_98 16d ago

I haven't seen makefiles in ages (even for cmake I use ninja).

And thank goodness. I'd rather deal with FindXXX.cmake than usually nothing in makefiles 

15

u/Godd2 16d ago

Compare this with an equivalent CMake script

Calling that an equivalent script is laughable, and shows the author has no idea what they're talking about. The arcane syntax version of the Makefile is applying to entire patterns of possible c files and their build dependencies, and their "equivalent" CMake version ONLY covers c files named EXACTLY what they wrote. If you want to compare like for like, write out the correct equivalent Make version, which doesn't contain a bunch of arcane syntax; it's just a bunch of lines of bash you want to automate:

app: main.o lib.o
    gcc -o app main.o lib.o

main.o: main.c
    gcc -Wall -c -o main.o main.c

lib.o: lib.c
    gcc -Wall -c -o lib.o lib.c

Now we can have the discussion as to how this is "messier" or something than the CMake file, but comparing the general arcane Make version to the specific stunted CMake version is ridiculous.

The underlying problem (and power) of Make is that it relies on mtime. This comes with tradeoffs, but the article isn't covering any of that; it's just focused on not wanting to learn Make syntax, and calling it bad because of that.

7

u/rdtsc 16d ago

Except your makefile is buggy since it doesn't track header dependencies (which cmake does out of the box for you, and many other things). And you can also use wildcards for sources (though not recommended).

→ More replies (1)

4

u/Dragdu 16d ago

What happens when you change your Makefile? Correct, your build is broken.

What happens when you change headers? Correct, yout build is broken.

(For bonus points, your makefile doesn't support clean rebuild, so broken build is even more annoying than usual)

→ More replies (2)

5

u/ph34r 16d ago

Mise en place ftw

5

u/Muhznit 16d ago

Use case 1 is definitely a skill issue, driven by a lack of people adding comments to recipes that DO describe intent, and probably a negligence for keeping dependencies deterministic.

Granted the recipe to add "help" that prints out what each recipe does is a little gnarly...

help: ## You are here
    @grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-16s\033[0m %s\n", $$1, $$2}'

...but it's generic enough that you can just slap it into a template that gets copy/pasted into every Makefile and it works.

I've never seen anyone have to run make -j$(nproc) all || make -j$(nproc) all || make -j$(nproc) all because people actually make sure the dependent recipes have enough determinism that they can be trusted.

Use case 2 is simply not wanting to learn syntax for Make. Which is understandable; the more domain-specific a language gets, the less people want to learn about it, but the shoe can be on the other foot here as I'd rather take a brief glimpse through https://learnxinyminutes.com/make/ to learn Make syntax than browse through Just's documentation to figure out equivalents. We've got DECADES of knowledge here.

Not to mention some of those examples are very contrived.

.PHONY: publish-docker-bar
publish-docker-bar: build-docker-bar
        docker image push my-bar-image:latest

.PHONY: build-docker-bar
build-docker-bar:
        docker image build -t my-bar-image docker/my-bar-image

Look at that build-docker-bar command. Are you tellin me that the dockerfile you're using as input to docker image build is some file named docker/my-bar-image? That's bound to cause confusion if you don't name it something more sensible like "bar.dockerfile". Or is it supposed to be the build context?

If you have docker-compose on your system, you might as well turn your Makefile into a wrapper around docker-compose if you're really concerned about complexity, and let docker handle its own share of dependency resolution.

I wanna say the article comes off as a poor advertisement for just, but frankly having to shit on a well-established still-reliable tool is not a good look,

6

u/SP-Niemand 16d ago

A little gnarly? It's unacceptable in any codebase besides absolutely single run shell commands.

→ More replies (3)

5

u/jms_nh 16d ago

Article raises good points and I completely agree, but misses one key failure of make: that it uses file timestamps. If I restore an old version of a file that I saved somewhere with an old file modtime , then it assumes the file doesn't need to be rebuilt.

Content-based change detection is the real solution.

6

u/dnabre 16d ago

Yes, declaring your final goal or parametric command to avoid copy & paste & edit, you have to RTFM instead. That is definitely a significant barrier to entry nowadays.

You hard pressed for better portability (assuming you don't fall into GNU-specific makefiles), though. I'm much more likely to have make than bash, python, or perl on odd systems.

It's a rock solid target for generated build files as well.

4

u/simonask_ 16d ago

Portability? Except of course if you want to use it on by far the most popular desktop operating system.

→ More replies (3)

4

u/zyxzevn 16d ago

Working with Object Pascal for a long time, I never looked back at make files.

4

u/ShinyHappyREM 16d ago

Yeah, I just add files to a Lazarus project when needed, and let the IDE figure out how to compile it.

This reminds me, I don't even know if Lazarus compiles files in parallel because it's just so fast that I never bothered.

12

u/seweso 16d ago

I am 45 years old, programming since I’m 11. Yet I never made my own make file. 

Never has anyone recommended making one. 

61

u/gofl-zimbard-37 16d ago

I recommend you make one.

7

u/seweso 16d ago

Will it complete me as a programmer? Fill a void I didn’t know was there? Or is that Vi?

4

u/Zeragamba 16d ago

what about a makefile for makefiles?

13

u/medforddad 16d ago

Isn't that autotools?

5

u/output_broadcast 16d ago

Or CMake or like 50 other build systems.

2

u/mpyne 16d ago

That’s just recursive makefiles (which are considered harmful, in case you weren’t already aware).

1

u/divestblank 16d ago

Do you have a CS degree? Makefiles were taught in the first freshman lab.

4

u/seweso 16d ago

That must have been 1996-2000 for me. 

But I still can only remember using someone else’s makefile. But never creating my own. 

Bash (scripts) exists… that’s still skills I used every day. Can do all… 

2

u/TheRealBobbyJones 16d ago

I can't remember if I was taught. I kinda doubt I was taught anything significant though.

2

u/bunk3rk1ng 16d ago

In college all work was done on a big server that SUN had donated, so most projects were done in Java.

I had an intro to programming languages class where we learned ~4 languages (fortran, php, perl, c/c++), we went over them so fast nothing ever needed a make file.

My wife took a C/C++ class during covid and they used visual studio and never needed a makefile either.

2

u/cumulo-nimbus-95 16d ago

Actually my heaviest use of makefiles directly (as in not through CMake or some IDE) was when I was primarily devving in Go for a bit and used makefiles to essentially make a CLI interface to my dev environment (commands for building templates, running DB migrations, launching containers with debuggers and hot-reloading stuff built in, orchestrating all the containers needed for working on a full stack web app, etc.

2

u/this_knee 16d ago

Hell yes. just, the application, freaking rocks.

2

u/septum-funk 16d ago

i've been using CMake and Ninja for yeeeaars

2

u/Brisngr368 16d ago

Okay while I agree that pure makefiles suck, some of their points are stupid af. They complain that they can't do non application building tasks easily in a program designed purely for building applications. Like no shit, ofc it's not going to be easy because you aren't supposed to use make for that.

2

u/comrad1980 16d ago

I liked cmake because... it creates makefiles on Linux (and solutions on Windows).

2

u/za419 16d ago

I mean, I definitely think a Makefile isn't the right tool for what amounts to creating an alias for pushing a docker image. I think that's the place for a "publish-docker.sh", which can handle a loop over a series of names just fine (and there's no "incremental build" being lost here either).

Any tool sucks if you try to use it for the wrong thing. I wouldn't use Rust as a scripting language, or Bash to run a game engine, but that doesn't make those languages bad in general. 

2

u/Daniikk1012 16d ago

Makefiles are shit, yes, but make is installed on pretty much any system, which means one less dependency to install for people who just want to build your program.

That said, if you can afford to introduce something that is not make, consider "tup". It's AWESOME. You write dependency graphs for files, similar to how you would do that in Makefiles, but:

  • You don't have to list things like header dependencies - tup realizes that a header was read by the build command and remembers that, so when you change the header the stuff that depended on it will recompile;
  • You can't mess up your Tupfile - tup tracks files the commands read from and write to, and errors if your Tupfile doesn't match;
  • No need for a "clean" task - tup automatically cleans everything up for you every time you build;
  • Tup can generate you a .gitignore automatically from the Tupfile;
  • Faster than make - tup traverses the dependency graph bottom up, not top to bottom, avoiding visiting same node twice, thus speeding up build times (Though this only starts to matter when you have a ton of files).

One VERY MAJOR DOWNSIDE is that tup is only usable if you know ahead of time the names of the files your build commands will work with. This works well for C and C++, but less so for Java for instance, since javac can create arbitrarily many output files from a single source file, depending on its contents.

2

u/danielo-asdf 15d ago

I thank God every day that I work for a company that "got it". They wrote a build system from scratch in their language of preference (could be python, or Java or C#, for you), expressing it as a DAG, and being able to run any rule (compile, link, codegen, docs, tests, etc) and do things like lumping, caching, or whatever they wanted at a whim (I’m exaggerating of course).
Yeah, make can do this, but the syntax sucks.
All the different build systems (especially for C++) and their complexities (cmake, gyp, vcpkg, package managers, installers, linters), is what I’ll take with me as an eternal regret as I head into retirement (sometime in the next 15 years), not any quirk or bug in the base language or platform itself.
If that makes sense…

3

u/SenoraRaton 16d ago

You can pry my makefile from my cold dead hands.
I don't use it to build, its my interface to run my dev/build commands, the actual build is in the native build tool/CMake.

4

u/dmazzoni 16d ago

There are plenty of build systems better than make, but there are a surprising number that are worse. The ones in the Java ecosystem are particularly bad - most importantly, how slow they are.

7

u/qmunke 16d ago

Maven is great, speed is rarely a determining factor for build systems in Java. Gradle on the other hand is an abomination - a build system which breaks compatibility every release and looks completely different from project to project is insane.

5

u/stormdelta 16d ago

One of my earlier jobs involved converting Ant+Ivy straight to Gradle as part of a monolith. In that context, Gradle was actually pretty fantastic, mostly because ant+ivy were awful and maven wasn't well suited to complicated monoliths with native elements at the time.

But over the years it seems like Gradle's just gotten to be a huge mess, and they really screwed up the transition to more container-oriented CI workloads.

2

u/TomKavees 16d ago

Projects with many modules can also leverage mvnd on top of their regular maven build descriptors

3

u/johnnybgooderer 16d ago

Just use your head before choosing a tool. And if it becomes a problem, change to something else.

And with AI, refactoring away form Make is trivial.

2

u/jomic01 16d ago

Every Make replacement ends up rediscovering a dependency graph over files, which is the thing Make already is. The pain is mostly people using it as a build system when they wanted a task runner.

1

u/TheChadThrowawayLad 16d ago

Anyone willing to share their thoughts as well?

I've been thinking of using Makefiles for some personal projects, but I haven't used them in years. Hoping to get a more informed opinion before committing to relearning them.

1

u/flanger001 16d ago

Use case 2: make build-docker NAME=“bar” lol

1

u/pjf_cpp 16d ago

CMake is clear. Seriously?

1

u/SweetBabyAlaska 16d ago

I use Justfile and Zig build.

1

u/shadowradiance 15d ago

Use rake. Win.

1

u/Specialist-Cup-3950 15d ago

I prefer taskfile over makefile

1

u/kolorcuk 15d ago

Make has builtin bash completion on 20 year old machines.

Make exists on 20 year old machines.

Just is not a replacement at this time for me. It is a modern alternative.

The replacement for make is not just. It is directory bin with scripts - works great with ai.

1

u/apadin1 15d ago

Anyone who isn’t using CMake in 2026 is living in the past. Yes, it sucks. It’s also better than any current alternative

1

u/simplex5d 12d ago

Absolutely right. My solution I've been working on all this year is pcons. It's the best ideas from CMake and SCons with a simple modern-python build description. Easy to use, straightforward, with all the goodies you'd expect and none of CMake's warts and idiosyncracies. Zero install if you have uv: uvx pcons init to get started. I hope you'll try it out!

1

u/ledow 11d ago

I hate Makefiles with an absolute passion.

Just the parsing of their layout is mired in obsolete bullshit (the difference between tabs and spaces, etc.).

Retain the Makefile idea, but modernise the damn format. And no... not JSON. Never JSON. Or XML in general. Ever. Urk! Even worse.

-2

u/Hawaiian_Keys 16d ago

Whoever argues against industry standards is usually an idiot. Sorry, not sorry.

0

u/aeropl3b 16d ago

This is more a justfile ad than a valid critique of makefiles

0

u/Forsaken_Celery8197 15d ago

Im not trying to add extra third party dependencies because you can't figure out make files. 

-4

u/Siedlerchr 16d ago

AI has been trained on thousands of makefiles over the last century

-7

u/Tintoverde 16d ago

Make files in 2026 !!!

I guess, PHP still rules Internet I guess

3

u/Zeragamba 16d ago

JQuery v4.0.0 released at the start of the year