buck2 VS shake

https://buck2.build/ https://github.com/facebook/buck2

Rust support is also rather good ;) https://github.com/facebookincubator/reindeer

Buck 2 by Facebook

NOTE: I won’t mention SBT and Leiningen here because, with all due respect, they are niche build tools. I also won’t discuss Kobalt for the same reason (besides, it’s no longer actively maintained). Additionally, I won’t touch upon Bazel and Buck in this context, mainly because I’m not very familiar with them. If you have insights or comments about these tools, please feel free to share them in the comments 👇

There's a new build system which works on similar ideas to buck: https://buck2.build/

I don't think all these pieces are open source yet, but https://github.com/facebook/buck2/blob/main/prelude/rust/rust-analyzer/resolve_deps.bxl is a snippet that is used to drive Rust Analyzer

We have a small example project that demonstrates what that would look like with buck2: https://github.com/facebook/buck2/tree/main/examples/bootstrap

There are a few references to NixOS on the code/issues.[0] I wonder what Meta's use case is for NixOS.

[0] https://github.com/facebook/buck2/search?q=nixos&type=issues

Another interesting implementation is Shake: https://shakebuild.com/

It is technically a Haskell DSL, but supports Ninja files, time estimates and has tools for linting and profiling.

They explicitly refer to Shake build system and Build Systems a la Carte paper.

The one paper that gave me hope about build systems was Build systems à la carte: Theory and practice, by Andrey Mokhov, Neil Mitchell, and Simon Peyton Jones. Among other things, it describes the theoretical underpinnings of the Shake build system. To be honest I believe any build system that ignores the maths described in this paper can safely be ignored. (You may however ignore the paper itself if the maths checks out. See Daniel J. Bernstein's redo, which matches Shake very closely.)

Yeah, they don't have to be terrible. I haven't used it, but people in my circles tend to really like Shake, which uses a Haskell embedded DSL to describe builds.

You could try Shake. It's a sane build system written by a former co-worker of mine. https://shakebuild.com/

Shake does require compilation as it's essentially just a Haskell library providing a DSL and it works just fine, I guess in gradle's case it's a thing about Java-typical overengineering and complete blindness to resource usage. Shake's underlying engine can actually go head-to-head with ninja itself when building ninja files.

Did you look at shake: https://shakebuild.com/ ?

For reasons I don't want to get into, I am building my own GHC package without cabal. The documentation is a little sketchy, but I've succeeded in build and installing it in my own user database (I'm on linux x86_64, using GHC 8.6.5). I am using shake to do all of this, and I've been pretty pleased with how it works.