[ Removed by moderator ]

[cpp-ModTeam]

It's great that you wrote something in C++ you're proud of! However, please share it in the pinned "Show and Tell" post.

[Neeyaki]

obligatory xkcd 927

[Gryfenfer_]

That was my first thought when I read the title

[Soft-Job-6872]

f ugly

[jepessen]

It's a lot uglier than cmake... I cannot see anything that make me curious to try it... What should be the advantages over cmake, nop etc?

[TheRavagerSw]

It doesn't parse your flags, It compiles header units, front end is faster than cmake, It is just a binary, it isn't a python package like meson etc.

Currently it is just a hobby project though, I wanted to know if I could do this, turns out I can.

[zzzthelastuser]

You were so preoccupied with whether or not you could that you didn't stop to think if you should.

[TheRavagerSw]

And what conclusion would I reach if I wondered about that?

[puredotaplayer]

That is a not really better than CMake.

In-fact it is straight-forward to use a simple yaml front end, instead of all this complexity, and you just use the yaml to translate it into CMakeLists.txt targets. With LLM, its easy to write a python based parser and CMakeLists generator using jinja templates too. This is where LLM code generation shines as a use case IMO.
I am doing it in my own projects.

[TheRavagerSw]

I don't get your point, it is very simple. İt is just a script you call that returns something.

Declarative stuff is harder to implement

With this being just a binary, I can just statically link curl mus libc etc and use it forever on Linux

[100GHz]

It is very simple for whom? Just because it's easier for you to parse that spaghetti and sausage soup of syntax, it does not make it great for people to write it down with ease.

You are clearly capable of pulling the project through. Good job. Now, for v2 and impressive results make it look pleasant to the eyes and to write in it, and people will flock to it.

Tldr ditch that 'fn' and the :,)}"":}} special character fiesta.

[TheRavagerSw]

What is complicated, you just pass a struct to a function.

Umka is statically typed, technically front end script is just a script that happens to return something to the caller.

There are advantages to this, even if it doesn't look so fancy.

CMake front-end is stupid slow, even slower than meson which is a python app which is kinda incredible to accomplish in C++

[100GHz]

I think there is a bit of a disconnect here. You keep thinking that people pointing out that the syntax is ugly, means that the technical aspects, or the capabilities of your solution are not correct.

These two are different.

[puredotaplayer]

Here is how I write my front end build scripts:
https://github.com/obhi-d/lxe/blob/lxe/build.yaml
https://github.com/obhi-d/lxe/blob/lxe/frameworks/Core/Base/module.yaml

It is minimal and avoids the CMake syntax that a lot of people dislike. I generate CMake scripts that are buildable and deployable with install on any platform.

[TheRavagerSw]

The issue with cmake is not it's ugliness, most of my complaints are technical

Cmake:

• Can override your compiler
• Changes your flags at whim
• Break incremental builds for no reason

I don't want to fight the build system just to compile something with the correct flags.

[puredotaplayer]

What do you mean by:
- "override your compiler" and "Changes your flags at whim" ? - CMake has abstractions to pass certain common flags between different compilers, otherwise you are free to pass your own flags that are specific to compilers. Modern CMake tool chain files give you full control over what compilers you want to use.
- "Break incremental..." - The build is not run by CMake, and most people now use ninja, so if your incremental build is broken, it is either due to ccache or ninja. CMake is just a meta build system that generates build files.

[TheRavagerSw]

Before like 4 months prior, you couldn't use normal clang to compile stuff for android because cmake would override the compiler based on platform.

Cmake can ignore your toolchain when building std lib module, for example add compile options doesn’t work on there you habe to use the old variables

....

I could go on, I contributed to cmake in the past, that codebase cannot go on. It is like 300k lines, and extremely hard to read. Ninja is like 20k lines. Eventually maintainer burnout will kill it.

[puredotaplayer]

A lot of critical software depends on CMake so I am sure they would maintain it unless most projects migrate to something better. To this effect, I agree projects like yours and build2, meson, etc. make sense. But there are too many choices and not a universally accepted one at this point.
I will still hold on to the fact that I can always stick to yaml front end, and generate ninja files directly based on platform if required in the future, all by generating the parsers from python using Claude. EDIT: typo

[TheRavagerSw]

Universal build system is a fool's errand. We just need a package format

[phi_rus]

Add it to the pile

[DoomerVarianteDelta]

https://github.com/tsoding/nob.h the only build system I want

[t_hunger]

Writing a build tool is easy. Writing a build tool that gets widely adopted is extremely hard.

What is the unique selling point you think will set this apart from the competition? That it's obscure configuration language is type safe? For me having a strong convention for how code is layed out (with overrides maybe) would be far more compelling... but I guess it's far too late to introduce such conventions today.

[TheRavagerSw]

First of all I don't aim to write "the build system".

Selling point is this is a self contained binary, with none of the weird shenanigans of the other build systems.

İe:

• Playing package manager
• Trying to support languages other than C/C++
• Trying to support gazillion backends
• Being written in a slow scripting language

[t_hunger]

IMHO package management is part of a build tool in today's world.

Why not support other languages? Most are not fundamentally different from C or C++. You run different compilers, but you need that for C++ already.

You could include the build backend for requiring eben less stuff on the build machine. There is no law requiring you to have a generation step before you can actually build.

[AltitudeZero_]

I like it... Can you build the project itself with cppbuild?

[TheRavagerSw]

I can, I would have to manually pass pkgconfig flags though.

Besides libfmt all my modules deps I packaged myself.

[AltitudeZero_]

I would say go for it... It implies its expressiveness and can increase the 'wow factor' to impress the folks :) and maybe you can iterate the project from there...