I hacked a CMAKE replacement, and maybe it's for you

Let’s be honest: CMake can feel like trying to read hieroglyphs while blindfolded.
Half the time it’s fighting you, the other half it’s pretending to help. And I use Linux at home and Microsoft at work. Bringing this together as a C++ developer is very painful.

So... I built something else.
Meet Bodge — The Idiotic Build System.

🧠 What Is “Bodge”?

bodge [/bɒdʒ/ verb] — make or repair (something) badly or clumsily.

Yeah. The name is self-aware.

I was frustrated by fiddling around with CMAKE on windows, and Visual Studio is absolutely painful and I was wondering why nobody tackled this issue.
So, as I learned in my puberty as a nerd, when nobody is willing to do, do it yourself, it started as a weekend experiment to see if I could make something that just builds C++ projects without ceremony — and before I knew it, I’d bodged together a fully functional cross-platform build system. Okay - to be honest I was wondering how easy it can be to have something in place that matches MAVEN or Cargo for C++. (See: https://github.com/el-dockerr/bodge)
And it was perfect for my work as well, so I spread the work in my Company, and in no time we had something useful that shrink the toolchain and dependencies. Just a G++ compiler and Bodge in place.
Without working around on CMAKE to get it run on Windows.
Same on Linux - just G++ and Bodge with a nice sleek .bodge file. No make no cmake, no wrong encoding, and no wrong formatting.

It’s minimal.
It’s hacky.
It’s surprisingly powerful.
And it might actually replace CMake one day (if I’m crazy enough to keep going).

🧩 Why Bodge Exists

If you’ve ever wrestled with CMake or other meta-build tools, you know the pain:

Layers of cryptic commands,

endless dependency hell,

and the creeping feeling that your build files are writing themselves.

Bodge aims to fix that by being simple, declarative, and self-contained — like Cargo for Rust or Maven for Java, but for good old C++.

All you do is define what you want to build, what compiler to use, and what libraries you depend on.
That’s it.
No ceremony. No black magic.

Here’s the best part: Bodge can even fetch your dependencies directly from Git repos, build them, and chain everything together automatically.

⚙️ The Philosophy

I wanted to design a build system that:

Uses a single human-readable config file (.bodge)

Works identically on Windows, Linux, and macOS

Lets you define dependencies, build sequences, and targets without tears

Doesn’t require external generators or a PhD in scripting

The dream?
A single executable that builds your C++ project — clean, predictable, and portable.

🧱 A Minimal Example

Here’s a dead simple .bodge file:

name: MyProject
compiler: g++
output_name: my_app
cxx_flags: -std=c++17, -Wall, -O2
sources: src/**
include_dirs: include
libraries: pthread, m

That’s all it takes.
Run bodge and you’ve got your binary. 🎉

Want to build for Windows or Linux specifically?

bodge --platform=windows_x64

Or check what platforms are available:

bodge platform

It’s that easy.

💡 Key Features

Bodge already does a lot — and I keep adding new stuff as I go. Some highlights:

🧩 Multi-Target Support

Build executables, shared libs, and static libs — all from one config.

⚙️ Automatic Source Collection

Just point to a folder (src/**), and Bodge gathers all .cpp files recursively.

🚀 Daemon Mode

Yes, it can watch your source tree and rebuild automatically when you save.
Perfect for active development and CI setups.

🪄 Build Sequences

Create workflows like “build → package → deploy” directly in your .bodge file:

sequence.deploy: build:main mkdir:dist copy:my_app.exe->dist/my_app.exe

🌍 Cross-Platform by Design

Supports Windows, Linux, Unix, macOS, ARM, and x86/x64 — automatically detecting your system and applying platform-specific flags.

🔗 Git Dependency Fetching

Need a 3rd-party library? Just list its repo in .bodge, and it’ll pull and include it automatically.
No more “clone this, copy that, run this script” nonsense.

🧰 Example: Multi-Target Project

Here’s a more advanced setup to give you an idea of Bodge’s structure:

name: MultiTarget
compiler: g++
global_cxx_flags: -std=c++17, -Wall, -static-libgcc, -static-libstdc++
global_include_dirs: include
# Shared library
libcore.type: shared
libcore.output_name: core
libcore.sources: src/lib/**
# Executable that depends on it
app.type: exe
app.output_name: my_app
app.sources: src/**
app.libraries: core
# Build all
sequence.build_all: build:libcore build:app

You can build everything or just one target:

bodge build app

Or run a whole workflow sequence:

bodge sequence build_all

🔁 It Builds Itself

Yep.
You can build Bodge using Bodge.
That was my personal “it’s alive!” moment.
Just run:

bodge --platform=windows_x86

Or, if you’re feeling nostalgic:

make all

💾 Download

You can grab precompiled binaries for Windows, Linux, and macOS from the GitHub Releases
.
Or clone the repo and build from source (it’s super straightforward).

❤️ Why You Might Love It

Bodge is not trying to be smarter than you — it’s trying to get out of your way.
You tell it what you want, it builds it, and it doesn’t argue.

If you’re tired of CMake boilerplate or opaque “meta scripts,” Bodge might just be the breath of fresh air you’ve been waiting for.

🧑‍💻 Contribute or Follow Along

This is still an early-stage project, but it’s already working nicely for small and medium C++ projects.
If you’re curious, or if you’ve cursed at CMake recently (we all have), check it out: https://github.com/el-dockerr/bodge

👉 GitHub: Bodge – The Idiotic Build System

Give it a ⭐ if you like where it’s going — it really helps me stay motivated to push the next features.

☕️ Final Thoughts

I didn’t set out to reinvent the wheel — I just wanted one that didn’t squeak.
If you’ve ever thought “CMake is overkill for my project,” give Bodge a try.
It’s small, self-contained, and fun to use — just the way C++ building should be.

Let’s make C++ building less painful, one bodge at a time.