ADR-0010: Nauxogenesis

Status: accepted
Date: 2026-07-25

Context

Traditional compiler bootstrapping makes an ancestral compiler build a descendant compiler until the descendant can compile its own handwritten implementation. That model does not express the architecture NAUX is pursuing: the compiler is meant to be derived from canonical executable semantics by Futamura projection, not maintained as a second semantic authority.

No software can appear on a new processor without an initial executable image. NAUX must acknowledge that physical origin without turning a temporary Rust seed or an ancestral compiler into a permanent product dependency.

Options considered

Decision

Adopt Nauxogenesis as the NAUX architecture for reaching generative sovereignty.

Nauxogenesis is the process by which NAUX derives a native implementation from canonical semantics through specialization, then reaches a reproducible, independently checked generative fixed point with no ancestral compiler or third-party software in the normal production graph.

The canonical relation is:

Iₙ = canonical Core-N0 interpreter artifact
Sₙ = NAUX specialization kernel artifact
Cₙ₊₁ = P2(Sₙ, Iₙ) composed with the checked NAUX native path

Cₙ₊₁ builds Iₙ₊₁ and Sₙ₊₁ from their canonical NAUX sources
Cₙ₊₂ = P2(Sₙ₊₁, Iₙ₊₁)

A release reaches the Nauxogenic Fixed Point only when:

1. I, S, and the generated C are accepted by their independent checkers;
2. Cₙ₊₁ rebuilds the canonical sources and regenerates Cₙ₊₂;
3. the two generations are bit-for-bit reproducible for the same declared target and inputs, or a recorded exception has an independently verified semantic-equivalence proof;
4. the canonical interpreter remains the semantic authority;
5. the production dependency report contains only NAUX-owned software above the declared ISA, firmware, and syscall-ABI boundary;
6. deleting Rust, Cargo, egg, and every bridge tool does not break a normal release build or ordinary NAUX compilation.

The first native artifact used to establish NAUX on a target is called a NAUX Origin Image. Moving an Origin Image to a new ISA is architecture genesis. An Origin Image is declared provenance, not a semantic authority and not a hidden production dependency.

Rust seed construction remains an explicitly temporary pre-Nauxogenesis migration mechanism. P2 alone does not establish Nauxogenesis while the specializer, interpreter, native path, or regeneration procedure still requires a bridge dependency.

Rationale

• The name captures the whole product property rather than only compiler generation.
• The compiler remains a derivative of executable semantics.
• The fixed-point gate makes self-generation reproducible and testable.
• Origin provenance stays honest without adopting ancestral-compiler architecture as the destination.
• Dependency closure is part of correctness, not a packaging afterthought.

Trade-offs

• NAUX accepts a substantially harder path than conventional self-hosting.
• A new term can be dismissed as branding unless every claim carries the required evidence.
• Bit-for-bit closure constrains nondeterminism, serialization, scheduling, and target descriptions throughout the toolchain.
• Architecture genesis still requires a declared executable artifact; the decision does not claim creation from nothing.

Consequences

Positive: interpreter, specializer, compiler, native path, and dependency policy now have one measurable closure target.

Negative: a compiler generated by P2 cannot be advertised as Nauxogenic until the complete closure gates pass.

Mitigation: publish the generation graph, semantic hashes, dependency report, raw regeneration artifacts, and checker results with every qualifying release.

Revisit trigger

Revisit the fixed-point equivalence rule only if a required target property is proven inherently nondeterministic and NAUX has an accepted, independently checked equivalence relation for that property. The semantics-derived compiler and zero-third-party production requirements are founding invariants.