lbt 1.0.1

LaurelBuildTool

A modern C/C++ build system powered by C# and .NET 9

English | 简体中文

LaurelBuildTool is a next-generation build system designed for C/C++ projects. It combines the power of C# scripting with the speed of native compilation, providing a clean, intuitive API similar to xmake but with modern tooling.

✨ Features

• 🚀 Simple API - Fluent C# scripting syntax for build configuration
• ⚡ Fast - Parallel compilation with incremental builds
• 🎯 Clean Output - All artifacts in unified build/ directory
• 🔧 Toolchain Detection - Auto-detects MSVC, GCC, Clang
• 📦 Multi-Module - Easy dependency management
• 💾 Intelligent Caching - Skip unchanged files with SHA256 tracking
• 🌍 Cross-Platform - Windows, Linux, macOS support
• 🛠️ IDE Support - Full IntelliSense for build scripts

📦 Installation

Prerequisites

.NET 9.0 Runtime is required to run LaurelBuildTool.

Check if installed:

# Windows
dotnet --list-runtimes | findstr "9.0"

# Linux/macOS
dotnet --list-runtimes | grep "9.0"

Install .NET 9.0:

• Windows: winget install Microsoft.DotNet.Runtime.9
• Linux: See .NET documentation
• macOS: brew install dotnet-runtime

Quick Install

# Install as .NET global tool (from NuGet.org)
dotnet tool install --global LBT

# Or build from source
git clone https://github.com/KhaosTian/LaurelBuildTool.git
cd LaurelBuildTool
dotnet build src/LBT.Cli/LBT.Cli.csproj -c Release

Your First Project

Create build.cs:

SetName("MyProject");
SetVersion("1.0.0");
SetLanguages("c++17");

Target("main")
    .AddFiles("src/*.cpp")
    .AddIncludeDir("include");

Create src/main.cpp:

#include <iostream>

int main() {
    std::cout << "Hello, LaurelBuildTool!" << std::endl;
    return 0;
}

Build and run:

# From your project directory (containing build.cs)
lbt build
lbt run

Build Output

All build artifacts output to a unified build/ directory, keeping source directories clean:

my-project/
├── build/
│   ├── debug/        # Debug builds
│   └── release/      # Release builds
├── src/             # Source (clean)
└── build.cs

Common Commands

lbt build              # Build project (Debug)
lbt build -c Release   # Build Release
lbt run                # Build and run
lbt clean              # Clean build artifacts
lbt -h, --help         # Show help

Multi-Module Projects

// lib/build.cs
Target("mathlib")
    .SetKind("static")
    .AddFiles("math.cpp")
    .AddIncludeDir(Visibility.Public, "include");  // Export headers

// Root build.cs
Include("lib");  // Include sub-module

Target("main")
    .AddFiles("src/*.cpp")
    .AddDeps("mathlib");  // Auto-inherits include dirs and links

📚 Documentation

• 💡 Examples
• 🤝 Contributing

🏗️ Architecture

LaurelBuildTool consists of three main components:

┌─────────────────────────────────────┐
│     build.cs (C# Script)            │
│  - Project configuration             │
│  - Target definitions               │
│  - Dependency management             │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│   Roslyn Script Engine              │
│  - Compiles build.cs at runtime      │
│  - Provides full C# capabilities     │
│  - Enables IntelliSense & debugging  │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│      Build Engine                   │
│  - Toolchain detection              │
│  - Parallel compilation             │
│  - Incremental builds (SHA256)      │
│  - Dependency resolution            │
└─────────────────────────────────────┘

Why Roslyn?

LaurelBuildTool uses Roslyn (C# compiler platform) for build scripting, which provides:

• ✅ Full C# Language - LINQ, async/await, pattern matching
• ✅ Type Safety - Compile-time error checking
• ✅ IDE Support - Full IntelliSense, debugging, refactoring
• ✅ Modern Tooling - Same ecosystem as Visual Studio

Trade-off: Requires .NET 9.0 Runtime (~44 MB download)

⚡ Performance

LaurelBuildTool is designed for speed:

Benchmarks

Compiling a medium-sized project (500 files, 100K LOC):

Benchmark: Windows 11, MSVC 2022, 16-core CPU

📊 Distribution

Why 44 MB?

• Roslyn Compiler (26 MB) - Core scripting engine
• EF Core + SQLite (12.4 MB) - Incremental build cache
• Spectre.Console (1.5 MB) - Terminal UI
• Other libraries (4 MB) - CLI, file matching, etc.

Comparison with other build tools:

• CMake: 50-70 MB
• xmake: 30 MB
• Meson: 5 MB + Python dependency

🔍 How It Works

1. Project Discovery

my-project/
├── build.cs          # ← LaurelBuildTool finds this
├── src/
│   └── main.cpp
└── include/

2. Script Compilation

lbt build
  ↓
Roslyn compiles build.cs
  ↓
Validates project configuration

3. Toolchain Detection

Auto-detect: MSVC → Clang → GCC
  ↓
Initialize compiler environment

4. Parallel Build

Source files → Object files (parallel)
  ↓
Link → Executable

🆚 Comparison

🤝 Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

Development Setup

# Clone repository
git clone https://github.com/KhaosTian/LaurelBuildTool.git
cd LaurelBuildTool

# Build (requires .NET 9.0 SDK)
dotnet build

# Run tests
dotnet test

# Build and run locally
dotnet run --project src/LBT.Cli/LBT.Cli.csproj -- build

📝 License

MIT License - see LICENSE for details.

🙏 Acknowledgments

• Roslyn - Powerful C# compiler platform
• CliWrap - Elegant command execution
• Spectre.Console - Beautiful terminal UI
• EF Core - Reliable caching system
• xmake - Inspiration for the API design

Note: This is a modern C++ build system. If you're looking for the classic CMake experience, this might not be for you. But if you want something simpler, faster, and more intuitive, give LaurelBuildTool a try!