Make was going crossplatform going back decades.

Your videos covering cmake are awesome. Any plans to explain autotools with this kinda detail@ explanations?

Great video! One aspect of CMake that I find challenging is the `find_package()` command. While it seems convenient at first glance, it often presents several frustrating issues. A common problem I encounter is when I install or download a third-party library and place it in a non-standard location. Each library tends to have its own method for handling this situation, sometimes requiring manual configuration of custom variables for the new location. I'm curious if there's a simpler or more universal approach to address this, perhaps through a single variable that can manage it all.

What a valuable knowledge. Any book that explains this detailed?

Big thanks for this. I was wondering a lot about this.

Really helpful video

can u also make a more in depth example vid on how each work includeing cmake?

Please show us how we can create this Android apk game!

The killer feature of build systems - dependency management, not incremental builds. Which files to build ,where to find internal/external dependencies, what order those dependencies should compile and how to pass those to linker and so on. Incremental builds could work just by using things like ccache and it's not necessary part of the build systems by itself. Also there's at least 4 kinds of compile times optimizations there are includnig caching, parallel building (multiple machine compile different parts of the project), multicore building and smashing files together into big ones. And of course they can be done all at the same time to a certain degree, since each of it introduce it's own quirks to the build system.

Meson the best

And Rust has one. Actually two, but that's Google's fault.

I wrote a simple build system in C++ with compile-time configuration In the build system library, there is simply a function that recursively compiles the files in a given directory into 1 executable file, and this is enough for me, the result is a simple configuration file and the compilation starts as quickly as possible Multiprocessor compilation is present

build systems are a psyop, you don't need them

Please compare meson to cmake.

One minute in and I'm infuriated no docs explained the gcc -o prog.exe *.o thing as well as you did

I personally don't get why people like to set a variable for source files. I'd just list them in the add_executable or add_library call directly, or better, use target_sources. That way you can enable modern C++ features like modules fairly easily and use generator expressions for any platform specific files. If the build becomes complicated enough to justify the variable and it cant be simplified, ok, introduce some variables, but I don't think they add any value as a default.

Making incremental builds using a shell script is actually quite easy. I just think that many people don't always want to put in the effort of learning shell scripting, thus the invention of fancy build systems.

I don't get why clang for Mac and not for all three, isn't making new programming languages uses cpp with llvm??

What stoppes me from checking if file changed in the script (for example using git hooks, hashing or timestamps) and then build only that .o, then link .exe file? If so, what's the caveats? Sorry if the question is stupid, only started to learn build systems and shell, and want to understand it's advantages and disadvantages.

"Please don't add another build system" XDDD

Subscribed. Waiting for the video

I’m really confused with what tools to use and how, I’m using Lua and Luau for automation but I can’t seem to figure out how to use FFI I also want to learn low level language like C/C++, Rust and Zig but it is really overwhelming

I really like CMake autoconf/make was a pain in the but

that's exactly what I was searching for! Learning C is rather simple, but when I started to search for compilers and build systems, I starting to get lost 🙈 Thank you for the explanation, and eager to watch the following videos 👍

But what if I need a specific feature that none of the build systems support?

i think the better solution could be to have build scripts in the project's main language, with *maybe* an (ideally small and uncomplicated one file) library to help implement incremental compilation where it's necessary that way everyone working on the project will already be proficient at the language they use to compile it, and at worst they'll have to learn how a small library works granted this only works if you keep the library small, as soon as you try to add a ton of unnecessary features to make it easier you completely ruin the whole idea of being easy to learn

These standards for build systems suck! I better add a new “better” standard to fix all the issues of the previous ones! /s (this is how we ended up here)

That last sentence was one of the funniest damn things I've heard in weeks.

It's funny that I've compiled so much code over the last decade, but I've never heard anyone break this concept down and state it so simply. Wish I had this video when I was confused and getting started! I AM going build another build system though. Sorry about that.

Great video, thanks!

subscribed, thanks

Nice

nice video bud

I hate CMake, but needless to say it is a necessary evil.

Why don't game studios use it to port their games to Linux?

Are you even a programmer? Or are you freestyling the learning?

I don't need to see the video to tell that this guy knows.

Im a Beginner,only able to write simple terminal applications but your content is simply amazing and easy to follow,i am grateful to have found your channel,wish you sucess buddy

I've been a software developer for 20+ years, and have read about but never really programmed in C++, but I have continuously read about it and its many changes over the years, and finally decided to get serious about picking up C++ because of all the things which you just can't do (well) in other languages-- things like GPU programming for non-graphics apps. Everybody talks about C++ as being full of foot-guns, but I see the language side as being manageable; the hardest part in getting started has been coming to grips with the build system (CMake), IDE integration, and most especially dependency management, and the lack of any any standard. Other popular modern languages either have a standard, or provide tooling for building and dependency management. Anyways, enough with the rant: your example of including raylib with CMake, was the first example that actually worked for me, and I'm including examples from textbooks. I immediately subscribed and purchased your CMake ebook, and am going through your other content also.

Small note. I would not speak in terms of "Visual Studio", which is the mostly name of the IDE, but the compiler name is actually specifically Visual C++, even though it can build both C and C++ code. Hence the abbreviation MSVC.

Hey, I see you answer questions in comments so I have to ask too. Let’s say there are assets that have to be packaged together with the binary. How would you install them with CMake, and how would you access these assets (relative/absolute paths) from the binary?

Wouldn't it be easier if windows just shipped with make

I loved the video, very simple and straightforward, no shenanigans of extra info and I like that I would be interested in a similar style video explaining the compilation process from having a source file to an actual binary executable (or library), with all the magic of linkers and preprocessing in between and maybe a video about how compiled binaries are laid in memory? (This stems from me reading about the -fpic flag) Great video, keep up the amazing content!

I love this channel, it's very helpful for me. I'm using CMake with CLion and MSVC compiler (best support for a new features, like C++ named modules, I was using clang before)

Blooper alert: I said CLion (and even showed the CLion logo), when I meant to say CLang. CLion is an Integrated Development Environment (IDE), whereas CLang is a compiler toolchain (based on LLVM).

I just checked your website and saw that the book is not finished yet. Maybe it would be useful to mention other build configurations as well, which are platform-specific, vendor-specific, and the qmake to get a wider and more complete view for the readers of the topic. A short hello-world example of each one could be a nice bonus.

I wish someone explained so clearly this years ago. Thank you very much! Am I correct if I assume that the configure/automake stuff is for the same purpose as CMake (but older and probably less advanced and non-multiplatform, etc?)

What is the difference between cmake and make, and is there any practical difference?

Thanks, have never worked with build systems like c make, but will definitely check.

Just something wrong with one compiler?