What is nova-nix?

Every module is pure by default. IO at the boundaries only.

Try It

git clone https://github.com/Novavero-AI/nova-nix.git
cd nova-nix
cabal run nova-nix -- --strict eval test.nix

{ count = 6; greeting = "Hello, nova-nix!"; items = [ 2 4 6 8 10 ]; nested = { a = 1; b = 2; c = 4; }; types = { attrs = "set"; int = "int"; list = "list"; string = "string"; }; }

That's let bindings, rec attrs, lambdas, builtins.map, builtins.typeOf, and arithmetic — parsed, lazily evaluated, and printed. On Windows, macOS, or Linux.

CLI

nova-nix eval FILE.nix                        # Evaluate a .nix file
nova-nix eval --expr 'EXPR'                   # Evaluate an inline expression
nova-nix build FILE.nix                       # Build a derivation
nova-nix --nix-path nixpkgs=/path eval FILE   # Add search paths (repeatable)

$ nova-nix eval --expr '1 + 2'
3

$ nova-nix eval --expr 'builtins.map (x: x * x) [1 2 3 4 5]'
[ 1 4 9 16 25 ]

$ NIX_PATH=nixpkgs=/path/to/nixpkgs nova-nix eval --expr '(import <nixpkgs/lib>).trivial.version'
"24.11pre-git"

$ nova-nix build hello.nix
/nix/store/abc...-hello

The build command evaluates, extracts the derivation, builds the dependency graph, checks binary caches, builds locally, and registers outputs.

Architecture

                    Pure Core (no IO)
  +------------------------------------------------+
  |                                                |
  |  Parser --> Expr.Types --> Eval --> Builtins    |
  |                 |           |                   |
  |          Expr.Resolve    Eval.Types             |
  |          Expr.ClosureTrim Eval.Operator         |
  |          Parser.Lexer    Eval.Compile           |
  |          Parser.Expr     Eval.StringInterp      |
  |                             |                   |
  |                        Derivation --> Hash       |
  |                             |                   |
  |                    Store.Path  DependencyGraph   |
  |                                                |
  +------------------------------------------------+
                       |
              IO Boundary (thin)
  +------------------------------------------------+
  |  Eval.IO  Store.DB  Store  Builder  Substituter |
  +------------------------------------------------+
                       |
           C99 Data Layer (off GHC heap)
  +------------------------------------------------+
  |  nn_symbol  nn_attrset  nn_thunk  nn_env       |
  |  nn_list    nn_ctxstr   nn_bytecode nn_lambda  |
  |  nn_arena                                      |
  +------------------------------------------------+

Key design decisions:

• Haskell owns eval logic, C99 owns data layout. The evaluator stays in Haskell. Data structures (attr sets, thunks, envs, values) live in C. Haskell calls C to create, query, and mutate data. C never calls back into Haskell.
• Bytecode-compiled evaluation. The 19-constructor Expr AST compiles to a flat 24-opcode bytecode array. The bytecode evaluator (evalBytecode) is the sole dispatch path. The AST is GC'd after compilation.
• MonadEval typeclass. PureEval (newtype over Either Text) for deterministic testing. EvalIO for real filesystem access. Same eval function, different effects.
• Arena allocation. Thunks, attr sets, envs, and lambdas are arena-allocated in C. Bulk free at eval end, zero per-object GC overhead. The GHC heap holds only control flow and StablePtr handles.
• Knot-tying via Haskell laziness. Recursive let and rec {} use two-phase construction: allocate slots, create env, fill slots. Thunks capture environments lazily via StablePtr so they can reference not-yet-filled arrays.
• Lazy derivations. derivation is a lazy wrapper over the eager derivationStrict primop (mirroring Nix's corepkgs/derivation.nix). Forcing a derivation to WHNF yields its attribute spine without computing drvPath/outPath or forcing its input closure — so referencing a package (pkg ? out, assert (dep != null)) is free.
• String context propagation. Every VStr carries a StringContext tracking store path references. The derivationStrict primop collects all context into drvInputDrvs/drvInputSrcs.

Performance

The C99 data layer moves all evaluation data off the GHC heap:

Measured on a stress test with 100k attribute sets, recursive computations, list operations, and overlay patterns.

nixpkgs status: import <nixpkgs/lib> evaluates correctly (450 attributes). lib.fix, lib.extends, lib.makeExtensible, lib.evalModules, and lib.systems.elaborate all work. The full stdenv bootstrap and package construction — perl, libxcrypt, binutils — now evaluate: derivation is a lazy wrapper over the eager derivationStrict primop (matching C++ Nix), so referencing a derivation no longer forces its build closure. Full import <nixpkgs> {} is currently blocked on a variable-resolution bug in named-formal-set (@-pattern) argument slots.

Windows Native

nova-nix runs natively on Windows — no compatibility layers, no translation.

Modules

Parser

Evaluator

C99 Data Layer

Store + Builder

Roadmap

Done

• Full Nix parser (14 precedence levels, all syntax forms)
• Lazy bytecode evaluator (24 opcodes, thunk memoization, blackhole detection)
• 109 builtins (matching real Nix spec)
• C99 data layer (9 modules, all eval data off GHC heap)
• Content-addressed store with SQLite metadata
• Derivation builder with dependency resolution
• Binary cache substituter with Ed25519 verification
• String context tracking and propagation
• nixpkgs lib layer evaluation (lib.fix, lib.extends, lib.evalModules)

Next

• Full import <nixpkgs> {} — bootstrap + package construction evaluate (lazy derivation); blocked on a named-formal-set (@-pattern) variable-slot bug
• --system flag — override builtins.currentSystem for cross-platform evaluation
• Windows stdenv — MinGW GCC + MSYS2 coreutils bootstrap for native Windows builds

Long-Term

• nova-nix shell — enter a development shell
• nova-nix repl — interactive evaluator
• Nix daemon protocol compatibility
• XZ decompression for binary cache downloads

Build & Test

cabal build                              # Build library + CLI
cabal test                               # Run all 593 tests
cabal build --ghc-options="-Werror"      # Warnings as errors (CI default)

Requires GHC 9.8+ and cabal-install 3.10+.

Library Usage

import Nix.Parser (parseNix)
import Nix.Eval (eval, NixValue(..), PureEval(..))
import Nix.Builtins (builtinEnv)

main :: IO ()
main = do
  case parseNix "<stdin>" "let x = 5; y = x * 2; in y + 1" of
    Left err -> print err
    Right expr -> case runPureEval (eval (builtinEnv 0 []) expr) of
      Left err  -> putStrLn ("Error: " ++ show err)
      Right val -> print val  -- VInt 11

The evaluator is polymorphic via MonadEval — PureEval for pure tests, EvalIO for filesystem access.

_{BSD-3-Clause · Novavero AI}