HN

Comments (99)

• Menu

  adev_
  Feedback of someone who is used to manage large (>1500) software stack in C / C++ / Fortran / Python / Rust / etc:- (1) Provide a way to compile without internet access and specify the associated dependencies path manually. This is absolutely critical.Most 'serious' multi-language package managers and integration systems are building in a sandbox without internet access for security reasons and reproducibility reasons.If your build system does not allow to build offline and with manually specified dependencies, you will make life of integrators and package managers miserable and they will avoid your project.(2) Never ever build in '-03 -march=native' by default. This is always a red flag and a sign of immaturity. People expect code to be portable and shippable.Good default options should be CMake equivalent of "RelWithDebInfo" (meaning: -O2 -g -DNDEBUG ).-O3 can be argued. -march=native is always always a mistake.- (3) Allow your build tool to be built by an other build tool (e.g CMake).Anybody caring about reproducibility will want to start from sources, not from a pre-compiled binary. This also matter for cross compilation.- (4) Please offer a compatibility with pkg-config (https://en.wikipedia.org/wiki/Pkg-config) and if possible CPS (https://cps-org.github.io/cps/overview.html) for both consumption and generation.They are what will allow interoperability between your system and other build systems.- (5) last but not least: Consider seriously the cross-compilation use case.It is common in the world of embedded systems to cross compile. Any build system that does not support cross-compilation will be de facto banned from the embedded domain.
• looneysquash
  Besides Cargo, you might want to take a look at Python's pyproject.toml standard. https://packaging.python.org/en/latest/guides/writing-pyproj...It's similar, but designed for an existing ecosystem. Cargo is designed for `cargo`, obviously.But `pyproject.toml` is designed for the existing tools to all eventually adopt. (As well as new tools, of course.)
• Menu

  gavinray
  The least painful C/C++ build tool I've used is xmakehttps://github.com/xmake-io/xmakeThe reason why I like it (beyond ease-of-use) is that it can spit out CMakeLists.txt and compile_commands.json for IDE/LSP integration and also supports installing Conan/vcpkg libraries or even Git repos. set_project("myapp") set_languages("c++20") add_requires("conan::fmt/11.0.2", {alias = "fmt"}) add_requires("vcpkg::fmt", {alias = "fmt"}) add_requires("git://github.com/fmtlib/fmt v11.0.2", {alias = "fmt"}) target("myapp") set_kind("binary") add_files("src/*.cpp") add_packages("fmt") Then you use it like # Generate compile_commands.json and CMakeLists.txt $ xmake project -k compile_commands $ xmake project -k cmake # Build + run $ xmake && xmake run myapp
• randerson_112
  Thank you everyone for the feedback so far! I just wanted to say that I understand this is not a fully cohesive and functional project for every edge case. This is the first day of releasing it to the public and it is only the beginning of the journey. I do not expect to fully solve a problem of this scale on my own, Craft is open source and open to the community for development. I hope that as a community this can grow into a more advanced and widely adopted tool.
• Menu

  bluGill
  Anyone can make a tool that solves a tiny part of the problem. however the reason no such tool has caught on is because of all the weird special cases you need to handle before it can be useful. Even if you limit your support to desktop: OS/X and Windows that problem will be hard, adding various linux flavors is even more difficult, not to mention BSD. The above is the common/mainstream choices, there Haiku is going to be very different, and I've seen dozens of others over the years, some of them have a following in their niche. Then there are people building for embedded - QNX, vxworks, or even no OS just bare metal - each adding weirdness (and implying cross compiling which makes everything harder because your assumptions are always wrong).I'm sorry I have to be a downer, but the fact is if you can use the word "I" your package manager is obviously not powerful enough for the real world.
• Menu

  looneysquash
  Nice. I have been thinking of making something similar. Now hopefully I don't have to!Not sure how big your plans are.My thoughts would be to start as a cmake generator but to eventually replace it. Maybe optionally.And to integrate suppoet for existing package managers like vcpkg.At the same time, I'd want to remain modular enough that's it's not all or nothing. I also don't like locking.But right now package management and build system are decoupled completely. And they are not like that in other ecosystems.For example, Cmake can use vcpkg to install a package but then I still have to write more cmake to actually find and use it.
• Menu

  lgtx
  The installation instructions being a `curl | sh` writing to the user's bashrc does not inspire confidence.
• Menu

  seniorThrowaway
  Having to work around a massive C++ software project daily, I wish you luck. We use conan2, and while it can be very challenging to use, I've yet to find something better that can handle incorporating as dependencies ancient projects that still use autoconf or even custom build tooling. It's also very good at detecting and enforcing ABI compatibility, although there are still some gaps. This problem space is incredibly hard and improving it is a prime driver for the creation of many of the languages that came after C/C++
• Menu

  Surac
  Uses CMAKE, Sorry not for me. Call me old but i prefere good old make or batch. Maybe it's because i can understand those tools. Debugging CMAKE build problems made me hate it. Also i code for embedded CPU and most of the time CMAKE is just overkill and does not play well the compiler/binutils provided. The Platform independency is just not happening in those environments.
• Menu

  sebastos
  The tough truth is that there already is a cargo for C/C++: Conan2. I know, python, ick. I know, conanfile.py, ick. But despite its warts, Conan fundamentally CAN handle every part of the general problem. Nobody else can. Profiles to manage host vs. target configuration? Check. Sufficiently detailed modeling of ABI to allow pre-compiled binary caching, local and remote? Check, check, check. Offline vs. Online work modes? Check. Building any relevant project via any relevant build system, including Meson, without changes to the project itself? Check. Support for pulling build-side requirements? Check. Version ranges? Check. Lockfiles? Check. Closed-source, binary-only dependencies? Check.Once you appreciate the vastness of the problem, you will see that having a vibrant ecosystem of different competing package managers sucks. This is a problem where ONE standard that can handle every situation is incalculably better than many different solutions which solve only slices of the problem. I don't care how terse craft's toml file is - if it can't cross compile, it's useless to me. So my project can never use your tool, which implies other projects will have the same problem, which implies you're not the one package manager / build system, which means you're part of the problem, not the solution. The Right Thing is to adopt one unilateral standard for all projects. If you're remotely interested in working on package managers, the best way to help the human race is to fix all of the outstanding things about Conan that prevent it from being the One Thing. It's the closest to being the One Thing, and yet there are still many hanging chads:- its terribly written documentation- its incomplete support for editable packages- its only nascent support for "workspaces"- its lack of NVIDIA recipesIf you really can't stand to work on Conan (I wouldn't blame you), another effort that could help is the common package specification format (CPS). Making that a thing would also be a huge improvement. In fact, if it succeeds, then you'd be free to compete with conan's "frontend" ergonomics without having to compete with the ecosystem.
• Menu

  flohofwoe
  Heh, looks like cmake-code-generators are all the rage these days ;)Here's my feeble attempt using Deno as base (it's extremely opinionated though and mostly for personal use in my hobby projects):https://github.com/floooh/fibsOne interesting chicken-egg-problem I couldn't solve is how to figure out the C/C++ toolchain that's going to be used without running cmake on a 'dummy project file' first. For some toolchain/IDE combos (most notably Xcode and VStudio) cmake's toolchain detection takes a lot of time unfortunately.
• Menu

  delduca
  Compared to Conan, what are the advantages?
• cherryteastain
  Seems to solve a problem very similar to Conan or vcpkg but without its own package archive or build scripts. In general, unlike Cargo/Rust, many C/C++ projects dynamically link libraries and often require complex Makefile/shell script etc magic to discover and optionally build their dependencies.How does craft handle these 'diamond' patterns where 2 dependencies may depend on versions of the same library as transitive dependencies (either for static or dynamic linking or as header-only includes) without custom build scripts like the Conan approach?
• Menu

  tombert
  This certainly seems less awful than the typical C building process.What I've been doing to manage dependencies in a way that doesn't depress me much has been Nix flakes, which allows me a pretty straightforward `nix build` with the correct dependencies built in.I'm just a bit curious though; a lot of C libraries are system-wide, and usually require the system package manager (e.g. libsdl2-dev) does this have an elegant way to handle those?
• Menu

  kjksf
  In the age of AI tools like this are pointless. Especially new ones, given existence of make, cmake, premake and a bunch of others.C++ build system, at the core, boils down to calling gcc foo.c -o foo.obj / link foo.obj foo.exe (please forgive if I got they syntax wrong).Sure, you have more .c files, and you pass some flags but that's the core.I've recently started a new C++ program from scratch.What build system did I write?I didn't. I told Claude:"Write a bun typescript script build.ts that compiles the .cpp files with cl and creates foo.exe. Create release and debug builds, trigger release build with -release cmd-line flag".And it did it in minutes and it worked. And I can expand it with similar instructions. I can ask for release build with all the sanitize flags and claude will add it.The particulars don't matter. I could have asked for a makefile, or cmake file or ninja or a script written in python or in ruby or in Go or in rust. I just like using bun for scripting.The point is that in the past I tried to learn cmake and good lord, it's days spent learning something that I'll spent 1 hr using.It just doesn't make sense to learn any of those tools given that claude can give me working any build system in minutes.It makes even less sense to create new build tools. Even if you create the most amazing tool, I would still choose spending a minute asking claude than spending days learning arbitrary syntax of a new tool.
• Menu

  nesarkvechnep
  As long as it's for C/C++ and not C or C++, I'm skeptical.
• thegrim33
  Project description is AI generated, even the HN post is AI generated, why should I spend any energy looking into your project when all you're doing is just slinging AI slop around and couldn't be bothered to put any effort in yourself?
• wild_pointer
  What about cmkr?https://cmkr.build/
• Menu

  littlestymaar
  “Show HN” has really become a Claude code showcase in the last 6 months, maybe it's time to sunset the format at this point …
• Menu

  wg0
  Yesterday I had to wrestle with CMake.But how this tool figures out where the header files and build instructions for the libraries are that are included? Any expected layout or industry wide consensus?
• anon
  undefined
• Menu

  dima55
  If you think cmake isn't very good, the solution isn't to add more layers of crap around cmake, but to replace it. Cmake itself exists because a lot of humans haven't bothered to read the gnu make manual, and added more cruft to manage this. Please don't add to this problem. It's a disease
• Menu

  mutkach
  Please consider adding `cargo watch` - that would be a killer feature!
• Menu

  duped
  FWIW: there is something fundamentally wrong with a meta-meta build system. I don't think you should bother generating or wrapping CMake, you should be replacing it.
• forrestthewoods
  Cmake is infamously not a build system. It is a build system generator.This is now a build system generator generator. This is the wrong solution imho. The right solution is to just build a build system that doesn’t suck. Cmake sucks. Generating suck is the wrong angle imho.
• einpoklum
  Impression before actually trying this:CMake is a combination of a warthog of a specification language, and mechanisms for handling a zillion idiosyncracies and corners cases of everything.I doubt than < 10,000 lines of C code can cover much of that.I am also doubtful that developers are able to express the exact relations and semantic nuances they want to, as opposed to some default that may make sense for many projects, but not all.Still - if it helps people get started on simpler or more straightforward projects - that's neat :-)
• spwa4
  Just switch to bazel, copy my hermetic build config and just use it ... yes, you can hate me know.
• anon
  undefined
• mc-serious
  [dead]
• shevy-java
  Will take C only 51 years to adopt.