Prove it · C+ reproducible evidence

Two-way C ABI, for real

cpc emits standard object files, so C+ links into a C build and C links back into C+, one symbol at a time. Mark the C-facing functions export extern fn, build, and link the object straight into a C program:

cpc build                          # emits a .o with C-ABI symbols
clang main.c target/.../libmath.o -o app   # a C program links C+ directly

Full walkthrough: the C ABI consumer.

Real-time contracts the compiler proves

#[realtime] (and #[no_alloc] / #[no_block]) are checked across the whole transitive call graph. A violation is a compile error, not a lint. Add an allocation to a proven function and it will not build:

#[no_alloc]
fn step(x: f32) -> f32 {
    let buf = vec::new::[f32]();   // E0901: heap allocation in a #[no_alloc] function
    return x;
}

Proven end to end on hardware: an allocation-free PID kernel on the ESP32.

Diagnostics you can act on programmatically

Every error carries a stable code, a source span, and often a machine-applicable fix, emitted as one JSON object per diagnostic:

cpc check --diagnostics=json

See the shape on Tooling, and the complete catalogue at Error codes.

The compiler's own view of the code

cpc query and cpc mcp expose a resolved, typed code graph, so an agent navigates by symbol and type instead of grepping text:

cpc query context sum_range

More: Tooling and Code graph, not grep.

Why there is no benchmark table

C+ is pre-1.0 and aimed at a different target than the established systems languages, so ranking it on a microbenchmark chart today would measure the wrong thing and set the wrong expectations. What can be said plainly: there is no garbage collector and no hidden runtime, generics monomorphize to concrete code, and the output is a native object file over the C ABI, so safety is paid for at compile time, not on every call. The honest invitation is to measure it on your own workload. It is cheap to try: install, compile, run, all in seconds.

Start