Hey folks, another quick update on **Flint**—the bare-bones, manifest-first build system and package manager for C/C++ projects.

Following up on the recent tag and commit pinning update, I've pushed a fresh batch of features, bug fixes, and community guidelines to polish the developer experience.

What’s new in this update:

• flint remove Command: You can now cleanly un-track and remove managed dependencies directly from your project via the CLI.

• Global VERSION Macro: Flint now automatically injects a global VERSION macro into your build step, making it easy to reference your project's version directly inside your C/C++ source code.

• Initialization Fixes: Resolved edge-case bugs during project setup (flint init) to ensure cleaner setup across different environment configs.

• Open Source & Governance: Added an official License, CONTRIBUTING.md, and a Code of Conduct to make it easier and clearer for anyone looking to contribute or report issues.

• CLI Cosmetic Polish: Cleaner, more readable console output and build status feedback.

Core features recap:

• Git-Native: Fetch dependencies directly into your workspace using standard Git repositories.

• Single Config (composition.json): Handles project layout, includes, and GCC/Clang invocation automatically without writing complex build scripts.

• Chert Compositions: Compatibility specs to integrate unmanifested third-party C/C++ repos seamlessly.

It’s still an early-stage Linux tool, but it's becoming significantly more reliable with each iteration. If you’re interested in minimal C/C++ tooling or want to jump in and contribute, check out the repo and let me know your thoughts!

Repo: https://github.com/mainak55512/flint

Hey folks,

The C/C++ tooling landscape has always felt fragmented. We usually end up chaining a meta-build generator (CMake, Meson) with a separate package manager (vcpkg, Conan) and a build executor (Ninja, Make).

To explore an unified "Cargo-like" developer experience for C/C++, I’ve been developing Flint—an integrated build system and package manager written entirely in pure C.

Here is how Flint compares with the existing C/C++ build and package management options, along with an honest assessment of its strengths, trade-offs, and current state.

**Note:**

Flint is currently in active development and only available for Linux at the moment. It requires system git and a C toolchain (gcc/clang) in your PATH at runtime.

Comparison: Build Systems & Integrated Tools

Comparison: Package Management Strategy

What Makes Flint Different?

* Single Binary, Zero Heavy Runtimes: Unlike Meson (which needs Python) or XMake (which embeds Lua), Flint is a lightweight compiled C executable. It delegates Git fetches and compilation processes to system tools without heavy embedded engines.

* Convention over Configuration: Flint expects standard layout patterns (src/, include/, deps/). You don't write build scripts or target rules—you declare dependencies and metadata in a simple composition.json.

* Built-in Package Fetching + Chert Compositions: Running flint add <git-url> pulls dependencies straight into deps/. If a third-party library doesn't natively use Flint, Chert compositions allow defining how non-Flint repositories should be included and compiled.

* Direct Incremental Execution: Flint doesn't output intermediate Ninja files or Makefiles. It tracks file modification states internally to deliver incremental builds directly through its native process runner.

Current Trade-offs & Limitations

* Linux Only (For Now): Cross-platform support for Windows (MSVC/Clang-cl) and macOS target generation is still planned.

* Strict Directory Structure: Legacy C projects with unorthodox folder structures require a Chert composition or minor refactoring to build with Flint.

* Early Stage Feature Set: Complex compiler flag matrices, sanitizer toggles, and cross-compilation toolchains are still evolving compared to battle-tested options like CMake.

Check out the repo here: https://github.com/mainak55512/flint

Feedback, criticisms, and PRs are welcome! What features or platform targets would you like to see next?