I am currently refactoring/porting the makefile to a new build system.
The main reason of this switch would be:
Fetching the tools/dependency at build time instead of keeping the archive in the repo. This would allow us to only version the url, version, hash and build steps for each packages instead of keeping every tarball in the project increasing the size of the repo like crazy each time we update a dependency. In fact once done, if we reset the repo, it should stay slim for ever.
Keeping the patch as diff file instead of overwriting whole files. It would allow us to easily spot changes and keep a smaller footprint once again.
Resumable build. If the build fail right now, it restart from scratch each time. Very tedious for working on the toolchain itself. The new build system keep state of what was done and what still need to be done. This way if something crash you can fix it and keep going.
Out of tree build. The project folder would be untouched after the build.
Clean-up currently the makefile make jump all over the place. Calling make from a make step isn't a good idea and should have been done with the make dependency system. It should be way easier to follow once the refactor done. I also suspect that the linux port would be easier to fix/finish.
Verbosity. The makefile is really verbose, the new system keeps thing really concise. It should be way easier for somebody to jump in and contribute. It also separate the big step in multiple file keeping everything compartmented.
The new build system would be based on libbuildtool, a dependency build system for our project. We open sourced it : https://github.com/anhero/libbuildtool
I will also make documentation for the build system before merging back.
The tool is written in ruby. This add a dependency on ruby, but since there is no compiled part, the tool could be bundled directly in the crossbridge repo. This way we can make a wrapper makefile and most people won't even notice the difference.