Frequently asked questions

A stateful execution architecture for evolving networks: deterministic, content-addressed network state, explicit transitions, invariant-gated verification before execution, branching with fail-closed semantic merge, and causal memory. It is an open-source architectural research project in Rust, not a product.

The complete, modeled condition of a network at a point in time — nodes, interfaces, and links as typed objects with canonical serialization. RAHN treats it as a first-class value you can hash, diff, branch, and verify. See network state.

Same inputs → byte-identical states, ids, and reports on every machine and every run. No nondeterministic iteration order, no timestamps as logic, no RNG, no hidden global state. Enforced by seeded property tests on multiple platforms in CI. See deterministic state.

A state's identity is the SHA-256 of its canonical serialization. Identity depends only on content: two states with the same bytes are the same state, wherever they occur. This makes integrity checkable, history immutable, and synchronization trustless. See content addressing.

Every transition must pass the constitution — a set of invariants evaluated deterministically over the state. Violations are rejected with the violated invariant, the offending objects, and the producing transition. rahn test turns verification into a CI-ready report with an exit-code contract. See network verification.

Rules that must always hold: a structural floor (referential integrity, link endpoints, no duplicate links, no self-loops) plus declared constraints like require-connectivity a b. The honest rule: "verified" means "all encoded invariants hold" — nothing more. See network invariants.

Nodes own first-class interfaces; links connect (node, interface) endpoints. Graph queries (shortest path, neighbors, reachability, connected components) and isolation constraints operate over that induced graph. Canonical format v2 carries the model (ADR 0011).

No. RAHN is an architectural research project at research maturity. It is not a production network controller, and v1.0 marks architectural stability — not production readiness. No production deployment, external review, or real-world operation exists.

No. RAHN does not manage devices or program forwarding. It versions and verifies a model of network state; SDN controllers could one day be consumers of such a model, which is a different role.

No. IaC tools declare desired configuration for provisioning engines. RAHN owns and versions the state itself — including observing it, branching it, and attributing causes — which is a different layer with different semantics.

It borrows Git's content-addressed object discipline, but the payload, change model, and safety model differ: typed topology semantics instead of text, explicit transitions instead of staged edits, a verification gate inside the state machine instead of CI outside it, and fail-closed semantic merge instead of textual three-way merge. See RAHN vs Git.

Yes — that is the default. Every plan executes in simulation against a backend that cannot touch the host, producing an inspectable description of what would happen.

Only opt-in and only isolated: --execute --yes-i-know, against Linux network namespaces, with host-side operations restricted to ip netns add/del rahn-*, after verification, on Linux only. The execution path is structurally unreachable without a verification result. See simulation-first execution.

Because the architecture's rules are enforceable in Rust's type system: pure transitions via ownership, strict typed parsing of untrusted input, memory safety at the namespace-execution edge, a determinism-friendly runtime, and a one-direct-dependency supply chain. The costs are stated too. See why Rust.

No, and it says so everywhere. v1.0 is architectural stability: frozen core model, frozen canonical format for 1.x, semver-stable SDK surface. It is not a production readiness claim, and the limitations baseline records what would have to change for that conversation.

No. The core is deliberately model-free: correct, explainable, and reproducible without any model. Causal memory records explicitly asserted relationships with epistemic status — it never infers. AI-as-advisor is a framed research question (RQ9) and a candidate for the future, outside the core.

Through the design-proposal → ADR path for architectural changes, or by picking a curated good first issue with acceptance criteria — measurement studies, fuzzing, CI matrix, documentation. The process is in contributing.

Clone the repository, cargo build, and run bash examples/demo/demo.sh — a simulation-only end-to-end walkthrough. The CLI walkthrough covers the full workflow. A Rust toolchain is the only requirement.