C-level performance. Rust-level safety. Go-level ergonomics. NovaC compiles straight to C99 with zero runtime overhead — so you can ship systems code that's fast, safe, and maintainable without the complexity tax.
use std.io; use std.net; fn main() -> Result<(), Error> { let server = net.listen(":8080")?; io.println("listening on :8080"); for conn in server { task.spawn(move handle(conn)); } return Ok(()); } fn handle(conn: Conn) -> Result<(), Error> { let req = conn.read()?; conn.write("hello, world")?; return Ok(()); }
Bounds-checked slices, explicit unsafe blocks, and no null pointer dereferences. Write systems code that doesn't crash in production.
Generics, traits, and pattern matching compile down to plain C with zero runtime overhead. You pay only for what you use.
Intelligent memory management across sessions, workspaces, and repositories. Persistent learning, context retention, and adaptive assistance.
No more header chaos. Explicit imports, clean visibility rules, and dependency resolution built for teams shipping at scale.
Call any C library directly. Ship NovaC alongside existing C code. Migrate incrementally without rewrites or FFI boilerplate.
L1 memory, L2 RocksDB, L3 distributed caching with >90% hit rates. Sub-millisecond incremental builds that scale.
Error messages that pinpoint the problem, explain the cause, and suggest the fix. Compiler errors that read like a senior teammate.
Build, test, format, lint, docs, and package management in a single CLI. No more wrestling with Make, CMake, autotools, or vcpkg.
We're building NovaC to scale from single-developer tools to enterprise deployments handling millions of lines of code daily. Here's our progress toward that vision.
Streaming parser, module system, multi-level caching foundation
Smart recompilation, dependency tracking, cache hit rates >90%
Worker pools, load balancing, fault tolerance - distributed compilation framework implemented
Prometheus metrics, health checks, structured logging - production-ready monitoring infrastructure
LLVM backend, performance profiling, optimization passes - advanced compilation framework implemented
Complete NovaC compiler ecosystem with production deployment, comprehensive testing, and documentation
NovaC's agent memory system remembers your preferences, patterns, and project context. It learns from every interaction to provide increasingly personalized and accurate assistance.
Remembers your coding patterns, preferred solutions, and project conventions across all workspaces and conversations.
Maintains conversation history and task context within active development sessions for seamless continuity.
Builds deep understanding of your codebase structure, dependencies, and development practices over time.
use std.io; fn main() -> i32 { io.println("Hello, NovaC!"); return 0; }
NovaC takes Rust's safety, Go's ergonomics, and C's performance — without their respective complexity, runtime, or footguns.
| Feature | C | C++ | Rust | NovaC |
|---|---|---|---|---|
| Memory safety | Manual / footguns | Smart pointers | Borrow checker | Safe by default, unsafe blocks |
| Error handling | errno / return codes | Exceptions | Result<T,E> | Result<T,E> + ? operator |
| Build system | Make / CMake | CMake / Bazel | Cargo | nvc (built-in) |
| Package manager | None | vcpkg / conan | crates.io | nvc add (built-in) |
| Compile speed | Fast | Slow | Slow | Very fast |
| Learning curve | Steep | Very steep | Steep | Gentle |
| C interop | Native | Native | Via FFI | Native (zero-cost) |
Recursive-descent parser, full AST, source maps
Direct C99 code generation with WASM playground
Strong static typing, inference, generics
Slices, borrow checking, defer semantics
nvc add, versioning, registry, lockfiles
Native code generation, optimization passes