CEBS: C++ Ergonomic Build System

CEBS is an unbloated, hyper-focused, multi-threaded C++23 build coordinator designed from the ground up to treat ISO C++20/C++23 Modules as first-class citizens.

By completely abandoning the Turing-complete macro engines, verbose scripting abstractions, and multi-stage generation loops found in legacy build systems (e.g., CMake, Meson), CEBS achieves near-zero configuration overhead and deterministic execution speeds.

---

Core Engineering Philosophy

1. Semicolon-Delimited Static Ingestion Pipeline

Traditional scanners rely heavily on line-oriented streaming (\n), which forces continuous heap re-allocations and complex tracking loops to handle multi-line preambles or arbitrary line breaks.

CEBS unifies its parsing pipeline by operating strictly on semicolon-delimited character chunks (;). Because the C++ language standard mandates that "export module", "module", and "import" declarations must terminate with a semicolon, the CEBS JIT scanner slices directly through files via low-level memory block iterations (::getdelim), completely stripping out line-handling overhead and achieving extreme data throughput.

2. First-Class Module Dependency Resolution

Legacy tools generate dependency sidecar files (.d) during compilation, which inherently breaks with modern modules because module binary interfaces (.gcm/.pcm) must be built prior to dependent units being touched. CEBS resolves this by executing a localized topological dependency graph analysis prior to invoking any compiler subsystems.

graph TD
    A[Manifest Ingestion] -->|Raw parse of 'cebs.build' chunks| B[Semicolon JIT Scanner]
    B -->|Tokenizes preambles, maps exports/imports| C[Directed Graph Engine]
    C -->|Links module dependency edges natively| D[Kahn's Topological Sort]
    D -->|Resolves compile layers DAG order| E[Thread-Pool Scheduler]
    E -->|Dispatches tasks concurrently to CPU cores| F[Binary Executable Generated]

    style A fill:#1f232a,stroke:#388bfd,stroke-width:2px,color:#fff
    style B fill:#1f232a,stroke:#388bfd,stroke-width:2px,color:#fff
    style C fill:#1f232a,stroke:#388bfd,stroke-width:2px,color:#fff
    style D fill:#1f232a,stroke:#388bfd,stroke-width:2px,color:#fff
    style E fill:#1f232a,stroke:#388bfd,stroke-width:2px,color:#fff
    style F fill:#1f232a,stroke:#238636,stroke-width:2px,color:#fff

Loading

---

Ergonomics: The Syntax Paradigm

Stop writing hundreds of lines of complex build scripting. CEBS enforces a clean, declarative, semicolon-terminated structural layout that mirrors C-style syntax.

The Contrast: CMake vs. CEBS

The Legacy Way (CMakeLists.txt)

cmake_minimum_required(VERSION 3.28)
project(SecureGateway CXX)
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
# Complex multi-step target & module scanning configuration
add_executable(gateway_bin)
target_sources(gateway_bin PUBLIC FILE_SET CXX_MODULES FILES src/core.cppm)
target_sources(gateway_bin PRIVATE src/main.cpp)
target_link_libraries(gateway_bin PRIVATE systemd X11)

The Ergonomic Way (cebs.build)

compiler = g++ ;
standard = c++23 ;
flags    = -O3 -Wall -Wextra ;

target   = demo_app ;
type     = executable ;
sources  = ./src ;
libs     = -lsystemd -lX11 ;

---

Architectural Feature Matrix

Functional Subsystem	Implementation Architecture	Ergonomic Impact
Manifest Parsing	Semicolon ::getdelim chunk streaming	Bypasses standard newline file overhead; single-pass lookups.
Dependency Scanning	Zero-allocation std::string_view preamble parsing	Identifies module interfaces instantly; safe from structural macro pollution.
Graph Logic	Directed Acyclic Graph (DAG) using Kahn's Sort	Prevents cyclic reference blocks; guarantees exact order compilation frames.
Job Scheduling	Thread-safe queue via std::jthread pool	Maximizes CPU core utilization by running independent tasks simultaneously.

---

Getting Started

1. Build CEBS Natively

CEBS is entirely self-bootstrapping and written in modern, standard C++23. Compile the engine using the included automated Makefile:

make clean
make

2. Configure Your Project Workspace

Create a folder named src/ and lay down your modern modular code blocks:

src/math.cppm

export module engine.math;
export namespace my_math {
    int add(int a, int b) { return a + b; }
}

src/main.cpp

import std;
import engine.math;

int main() {
    std::println("Result: {}", my_math::add(10, 5));
    return 0;
}

3. Compile Instantly

Drop your cebs.build file in the root directory and run the engine binary:

./cebs

---

License

copyright mxreal64, 2026

CEBS is distributed under the highly permissive MIT License. For full legal conditions, please refer to the accompanying LICENSE file contained within this repository infrastructure.