NovaLang — Next-Gen Systems Language
A modern systems programming language combining C++ performance, Python ergonomics, and Rust safety. Features hybrid memory management (GC/manual/arena), built-in ML support with @differentiable, async/await with actors, and LLVM-backed codegen.
Visit website
The vision
Every major systems language forces painful trade-offs. C++ offers raw performance but its syntax is hostile and memory management error-prone. Rust provides safety but has a steep learning curve and rigid ownership rules. Python is ergonomic but fundamentally too slow for systems work. NovaLang (.nv) is designed to unite all three: the performance ceiling of C++, the developer experience of Python, and the memory safety guarantees of Rust — without the baggage of any.
Hybrid memory management
NovaLang's most distinctive feature is per-module memory strategy selection via the @memory annotation. Developers choose between garbage collection, manual management, arena allocation, or linear types — matching memory strategy to domain requirements rather than fighting a one-size-fits-all model.
A high-throughput network service might use arena allocation for request processing, while a data science module uses GC for convenience, and a kernel driver uses manual management for deterministic cleanup — all in the same project.
Built-in ML primitives
NovaLang includes first-class tensor types and the @differentiable annotation for automatic differentiation — no external frameworks needed for basic ML workloads. This makes it possible to embed gradient-based optimization directly into systems code.
Combined with async/await backed by an actor model with channels, compile-time metaprogramming (comptime), algebraic types with pattern matching, and classes with interfaces, the language provides a cohesive feature set for modern systems development.
Compiler pipeline
The compiler follows a classic multi-stage pipeline: Lexer → Parser → AST → Type Checker → MIR (Mid-level IR) → LLVM IR → Native code or WebAssembly. Built in C++20 with CMake, it uses LLVM 14+ for backend codegen and NASM for assembly components. The lexer, parser, AST infrastructure, and type system are complete, with LLVM codegen and runtime actively in development.
A built-in REPL with AST/token display toggles enables interactive development and language exploration. The language supports both modern syntax (def, class, var) and legacy keywords (fn, struct, mut, trait, impl) for developer familiarity, drawing inspiration from Rust, Go, Python, Swift, and Julia.