SYSTEMS LANGUAGE · C99 OUTPUT · RUST COMPILER

The Systems Language
That Doesn't
Compromise.

NovaC compiles to clean C99 via a Rust compiler — giving you zero-cost abstractions, memory safety without a garbage collector, and native speed through GCC or Clang. Write systems code that's 5× faster to develop than plain C.

$cargo install novac// or: brew install novac
main.ncNovaC 1.0
// fibonacci.nc
fn fib(n: i32) -> i32 {
    if n <= 1 { return n; }
    return fib(n-1) + fib(n-2);
}

fn main() -> i32 {
    let result = fib(10);
    println("fib(10) = {}", result);
    return 0;
}

$ novac build fibonacci.nc
  → C99 codegen: 0.4ms
  → GCC -O2:     12ms
  ✓ fibonacci (native, 8.2 KB)
5×
faster to write than C
C99
native output
BLAKE3
content-addressed cache
Zero
GC pauses

Why NovaC

Modern systems programming,
without compromise.

NovaC is not a research language. It is a practical tool for writing the fastest code on the planet — with the ergonomics that modern developers expect.

🛡️
No GC, No Leaks

Memory Safe

Ownership and borrow checking at compile time — the same model proven by Rust, expressed in a language that feels like modern C. No garbage collector, no runtime pauses, no use-after-free.

⚡
Compile Away to Nothing

Zero-Cost Abstractions

Higher-level constructs — iterators, closures, generics — compile to exactly the C99 you would have written by hand. If you don't use a feature, you don't pay for it. No virtual dispatch tax.

🔩
C99 → GCC / Clang

Native Speed

NovaC outputs clean, human-readable C99 which your existing C toolchain compiles to native machine code. You get LLVM or GCC optimisations for free — O2, O3, LTO, PGO, all supported.

Compiler Architecture

From source to silicon
in one clean pipeline.

Written entirely in Rust, the NovaC compiler uses a nom PEG parser and a multi-stage IR to produce clean, human-readable C99 — which your existing C toolchain compiles to blazing native code.

Source.nc file01Lexertokens02nom ParserPEG grammar03ASTsyntax tree04HIRhigh-level IR05MIRmid-level IR06C99 Codegenemit C9907GCC / ClangC compiler08Native Binarymachine code09
Source
.nc file
Lexer
tokens
nom Parser
PEG grammar
AST
syntax tree
HIR
high-level IR
MIR
mid-level IR
C99 Codegen
emit C99
GCC / Clang
C compiler
Native Binary
machine code

Build Cache

Three-tier cache.
BLAKE3 content-addressed.

Every compilation artifact is keyed by the BLAKE3 hash of the source content — not timestamps, not filenames. Identical code never compiles twice, whether on your laptop, CI, or a remote build node.

cache key =BLAKE3(source_fragment + compiler_version + flags)
⚡L1
LRU
In-Memory Cache
100 MB
Size
Process-local
Scope
< 1 µs
Latency

Hot compilation units live here. Key = BLAKE3 content hash of source fragment. Evicted LRU when 100 MB limit is hit. Warms up in the first build and stays hot across incremental rebuilds.

🗄️L2
Persistent
RocksDB Cache
10 GB
Size
Local disk
Scope
< 1 ms
Latency

Persistent on-disk cache backed by RocksDB. Survives process restarts and CI cold starts. Content-addressed by BLAKE3 so identical source fragments share a single cache entry across branches.

🌐L3
Distributed
Distributed Cache
Unlimited
Size
Team-wide
Scope
< 50 ms
Latency

Shared across your entire build fleet. Enables distributed compilation — each node contributes to and consumes from the shared object store. Keys are BLAKE3 content hashes so cache hits are deterministic.

Cache lookup flow
Compile Unit
→
BLAKE3 hash
→
L1 hit?
→
L2 hit?
→
L3 hit?
→
Compile + store

Language Tour

NovaC on the left.
Generated C99 on the right.

Every NovaC feature maps transparently to idiomatic C99. No hidden runtime, no surprises — inspect the output with novac emit-c.

NovaCsource
// hello.nc — NovaC hello world
fn main() -> i32 {
    let name: str = "NovaC";
    let version: i32 = 1;

    println("Hello from {} v{}!", name, version);

    // Structured loops — no undefined behaviour
    let primes: [i32] = [2, 3, 5, 7, 11, 13];
    for p in primes {
        println("  prime: {}", p);
    }

    return 0;
}
Generated C99novac emit-c
/* hello.c — emitted by novaC codegen */
#include <stdio.h>

int main(void) {
    const char *name = "NovaC";
    int version = 1;

    printf("Hello from %s v%d!\n", name, version);

    static const int primes[] = {2,3,5,7,11,13};
    for (int i = 0; i < 6; i++) {
        printf("  prime: %d\n", primes[i]);
    }

    return 0;
}

Browser Playground

Write NovaC
in your browser.

The WASM-compiled NovaC playground lets you write, compile, and run NovaC code without installing anything. See the generated C99 and the compiler pipeline output in real time.

novac-playground.vercel.app
fn main() -> i32 {
    println("Hello, NovaC!");
    return 0;
}
Hello, NovaC!0.3ms · WASM

Observability

Full visibility into
every build.

NovaC ships with first-class observability baked into the compiler daemon — not bolted on as an afterthought.

📊

Prometheus Metrics

Compiler exposes /metrics with build duration, cache hit/miss rate, HIR/MIR pass times, and codegen throughput. Scrape-ready out of the box.

🔭

OpenTelemetry Tracing

Every compilation stage emits OTLP spans. Trace a slow build from source parse through to binary link in your existing Jaeger or Tempo instance.

🌐

Distributed Compilation

novaC-dist shards work units across build nodes. Cache keys are BLAKE3 content-addressed, so nodes never duplicate effort. Scales linearly with node count.

GET /metricsPrometheus format
# HELP novac_build_duration_seconds Duration of a full build
# TYPE novac_build_duration_seconds histogram
novac_build_duration_seconds_bucket{le="0.01"} 82
novac_build_duration_seconds_bucket{le="0.1"}  194
novac_build_duration_seconds_count          212

# HELP novac_cache_hits_total Cache hits by tier
# TYPE novac_cache_hits_total counter
novac_cache_hits_total{tier="L1"} 3841
novac_cache_hits_total{tier="L2"} 942
novac_cache_hits_total{tier="L3"} 107

# HELP novac_cache_misses_total Cache misses (compile required)
novac_cache_misses_total        48

Installation

Ships via cargo
or the novac CLI.

Install from crates.io or use the standalone installer. The CLI handles building, running, formatting, and project management.

via Cargo
$cargo install novac
via Homebrew
$brew install hyperbridge/tap/novac
via Shell
$curl -sSf https://get.novac.dev | sh

CLI Reference

novac --help
novac buildCompile .nc files to native binary via C99
novac runBuild and execute immediately
novac emit-cOutput generated C99 to stdout
novac checkType-check without generating output
novac fmtFormat source files in place
novac newScaffold a new NovaC project
novac distDistributed build across build nodes
novac cacheInspect and manage the build cache
OPEN SOURCE · HyperBridge Digital

C99 output.
Modern developer experience.

NovaC gives you the performance of C with the ergonomics of a modern language — and it compiles to the C99 you can read, audit, and trust.

▶ Try in Browser★ Star on GitHubHyperBridge Digital →
Rust compilernom PEG parserC99 outputBLAKE3 cacheMemory safeZero GCPrometheus metricsOpenTelemetryDistributed buildsWASM playground