System requirements
glibc 2.17+ or musl
Apple Silicon or Intel
x86-64; MSVC 2022 toolchain
Clang, MSVC, or GCC
Installation
Nova is pre-alpha — there are no pre-built packages yet. Build the compiler from source; the steps below work the same on Linux, macOS, and Windows.
Prerequisites
Install a stable Rust toolchain (1.85+). To compile Nova programs you also need a C toolchain — Clang, MSVC, or GCC (auto-detected).
Nothing else to install: the runtime's C dependencies (libuv and the Boehm GC) ship as submodules and are built once, automatically, on your first nova build.
rustup update stableClone and build
git clone --recursive https://github.com/nv-lang/nova
cd nova/nova-cli
cargo build --releaseThe --recursive flag pulls in libuv, a git submodule the runtime needs. Already cloned without it? Run git submodule update --init inside the repo.
The CLI binary lands at nova-cli/target/release/nova (nova.exe on Windows). Add that directory to your PATH.
Run the test suite (optional)
cd ..
nova-cli/target/release/nova test spec_tests/conformanceCompiles and runs the language conformance suite through the compiler you just built. A full run takes tens of minutes — skipping it is fine; building the hello-world below is a quicker toolchain check.
Your first Nova program
Create a file called hello.nv in the root of the cloned repository — nova build looks upward for the workspace's nova.toml:
module hello
fn main() {
println("Hello, Nova!")
}Compile to a native binary, then run it:
nova build hello.nv -o hello
./helloOutput
Hello, Nova!
Effects in 30 seconds
Nova requires every side effect to be declared in the function signature. The compiler verifies that no undeclared effects are performed — at compile time, not at runtime.
// Effects appear between parameters and return type.
// Io means this function may perform I/O.
// The compiler rejects calls to Io functions from non-Io contexts.
fn greet(name str) Io -> () {
println("Hello, ${name}!")
}
fn main() {
greet("Nova")
}Effects appear between parameters and the return type. The compiler verifies statically that every effect is declared — no hidden I/O, no surprise failures.