RAHN v1.0.0 — Stable Architecture

RAHN v1.0.0 — Stable Architecture

Stable release · tag v1.0.0.

RAHN is a stateful execution architecture for evolving networks — it gives networks state, memory, causality, and verifiable evolution.

What v1.0 delivers

• Deterministic network state: interface-based topology, canonical serialization (format v2), content-addressed identity — byte-identical across machines and runs (test-enforced).
• Verifiable evolution: explicit recorded transitions, semantic diff, branches, fail-closed semantic merge, constitution-gated commits (including isolation constraints).
• Execution, safely: dependency-safe execution plans; simulation backend by default; opt-in isolated Linux namespace backend with structural host-safety guarantees.
• Memory: provenance-bearing observation records and asserted, status-labeled causal edges — with the honest boundary that edges are asserted, never inferred.
• Distribution: peer sync over content-addressed history with byte-identical merge-commit convergence; conflicts fail closed and persist.
• CI: rahn test with a deterministic report and exit-code contract.
• Stability contract (ADR 0019): semver via rahn-sdk (curated, doctested, surface-guarded API) and CLI contracts; IR format frozen for 1.x; stable extension model (backends, invariants, observations, sync).

Evidence

All claims are claim-status-marked in the white paper and stage reports (docs/research/stages/): single-machine measurements for state scaling (10–100k objects), observation ingestion, causal-graph operations, and sync transport; CI-validated namespace execution on a minimal scenario.

Explicit non-claims

No linearizability or cross-replica strong consistency; no causal inference or AI reasoning; no addressing/traffic control; no signed transitions or authenticated replicas; no binary-reproducibility verification.

Known limitations

See docs/research/limitations.md and docs/research/v1.0-review.md (carried-forward items: performance debts, single-machine measurements, minimal execution scenarios).

For downstream users

Build against rahn-sdk (see its crate docs). CLI contracts and the IR are stable for 1.x; breaking changes require MAJOR + migration notes.

Next

Post-1.0 development continues inside the extension model: addressing, traffic control, dataplane backends, signed transitions, log replication — each requiring its own ADR.

RAHN v0.9.0-alpha — Programmability

rahn-sdk curated public API facade (prelude, doctested examples, compile-time surface guards); IR formally declared (ADR 0018): transition Operations + canonical byte encoding; DSL deliberately deferred. Pre-1.0 versioning policy documented. See docs/research/stages/v0.9.md.

Pre-release; superseded by v1.0.0.

RAHN v0.8.0-alpha — Network CI / Verification

rahn test [ref] — deterministic TSV verification report over any committed state with exit-code contract (0/1/2) for CI pipelines (ADR 0017); invariant ids are a machine contract; example GitHub Actions gate in examples/network-ci.yml. See docs/research/stages/v0.8.md.

Pre-release; superseded by v1.0.0.

RAHN v0.7.0-alpha — Execution Backends

ExecutionBackend trait (ADR 0016) with capability negotiation; simulation backend (default, description-only) and linux-ns backend behind the same interface (ADR 0012 semantics unchanged); rahn apply --backend; explicit refusal of unsupported capabilities. No dataplane code yet. See docs/research/stages/v0.7.md.

Pre-release; superseded by v1.0.0.

RAHN v0.6.0-alpha — Distributed State

RAHN v0.6.0-alpha

Stage 6 introduces distributed state synchronization over content-addressed
history.

Highlights

• Added peer synchronization model based on immutable state history.
• Added distributed consistency model (ADR 0015).
• Added deterministic state synchronization between peers.
• Preserved canonical state identity across replicas.
• Added distributed synchronization benchmarks.
• Updated architecture, specification, and research documentation.

Design Principles

RAHN does not attempt to become a generic distributed database.

Instead, it focuses on:

• deterministic state evolution
• verifiable synchronization
• explainable distributed history
• content-addressed network state

Research Status

This release provides an experimental distributed-state foundation.

It does not yet provide:

• production cluster management
• authentication infrastructure
• automatic conflict resolution
• large-scale WAN deployment

Next

v0.7.0-alpha — Network Reasoning Layer

RAHN v0.5.0-alpha — Causal Memory

RAHN v0.5.0-alpha — Causal Memory

Pre-release. Tag: v0.5.0-alpha (commit 96a9c9e). Publish as Pre-release, category: Announcements.

RAHN is a stateful execution architecture for evolving networks — it gives networks state, memory, causality, and verifiable evolution. This release adds the "causality" piece as asserted, honestly-labeled structure: RAHN records and queries causal relations; it does not infer them.

Highlights

• Causal edges between immutable anchors — obs:<seq> (v0.4 observation log) or commit:<id> (content-addressed commits).
• Strict epistemic statuses: temporal-correlation (ordering only), hypothesis (suspected link), verified — the last structurally restricted to edges whose both anchors are commits, the only mechanically checkable provenance class.
• DAG validation: cycle-closing insertions rejected (deterministic DFS); dangling anchors rejected against both logs.
• Append-only causal log (.rahn/causal.log) with versioned framing; corruption refused loudly, never repaired.
• CLI: rahn relate <from> <to> <status> --note <text> and rahn explain <anchor> — incidents as connected components, output carrying edge statuses verbatim. The system never generates edges automatically.

Evidence (measured, single machine)

10 000-edge linear chain: graph build 18.5 ms · deepest-case cycle check 4.3 ms · incident query 5.7 ms — the last after fixing an O(V·E) first implementation (2 701.9 ms) found by the benchmark itself. Methodology: docs/research/stages/v0.5.md.

Known limitations

• Edges are human-asserted; RAHN validates structure, proves nothing about the world.
• No automatic edge extraction, no causal inference, no AI reasoning, no distributed causal memory.
• Incidents are implicit components; named incident records and narrative explain <incident> are future work.
• Addressing and traffic control remain deferred (Stage 2/3 scope), limiting real-telemetry exercises.

Compatibility

No canonical-format change for states; causal.log is a new artifact with its own versioned framing.

Next

v0.6 — Distributed State, requirements-first (RQ7) before any replication mechanism is chosen.

Full context: CHANGELOG · Stage 5 report · ADR 0014 · White paper

RAHN v0.4.0-alpha — Observability

RAHN v0.4.0-alpha

Stage 4 introduces the initial observability foundation for RAHN.

Highlights

• Added the deterministic Observation model (ADR 0013).
• Added typed observation values:
  • Counter
  • Gauge
  • Event
• Added deterministic (time_ns, seq) ordering.
• Added an append-only, versioned observation log.
• Added state-linked observation provenance.
• Added strict malformed-input rejection.
• Added rahn observe and rahn observations.
• Added reproducible observation-ingestion benchmarks.

Research

Initial single-machine measurements cover observation ingestion, reading,
serialization size, and ordering behavior.

The observed per-append cost is currently dominated by opening, writing, and
flushing the log. This is recorded as known performance debt rather than
prematurely optimized.

Architecture

Observations remain separate from canonical network state and are associated
with state through validated provenance.

This preserves deterministic state identity while providing an evidence layer
for future causal analysis.

Limitations

• No causal semantics yet.
• No distributed observation ingestion.
• No production-scale telemetry pipeline.
• Link-level observation subjects and richer network metrics remain future work.

Next

v0.5.0-alpha — Causal Memory

RAHN v0.3.0-alpha — Isolated Linux Execution

RAHN v0.3.0-alpha

This release introduces RAHN's first real network execution backend through isolated Linux network namespaces.

Highlights

• Added the rahn-exec execution backend.
• Added isolated Linux network namespace execution.
• Added deterministic virtual Ethernet (veth) link creation.
• Added translation from RAHN link state to Linux network operations.
• Added explicit opt-in execution for real network changes.
• Kept simulation as the safe default.
• Added cleanup and recovery handling for isolated execution.
• Added Linux CI coverage for namespace execution.

Architecture

RAHN now has a clear execution boundary:

RAHN State
    ↓
Execution Plan
    ↓
Linux Execution Backend
    ↓
Network Namespace
    ↓
veth / virtual links

The abstract RAHN state remains independent from the Linux-specific execution backend.

Safety

Real network execution is explicitly opt-in.

Simulation remains the default, and execution is performed within isolated Linux network namespaces rather than modifying the host network by default.

Testing

Stage 3 adds coverage for:

• namespace creation
• veth setup
• link mapping
• execution planning
• cleanup
• failure recovery
• host-safety behavior

Linux-specific execution is validated in CI.

Known Limitations

This release does not yet include:

• typed network addressing
• full routing configuration
• traffic control
• observability
• causal memory
• distributed state
• eBPF/XDP backends
• P4 backends
• production network orchestration

Execution is currently limited to the isolated Linux backend introduced in this milestone.

Next

v0.4.0-alpha — Observability

RAHN v0.2.0-alpha — Network Graph Semantics

RAHN v0.2.0-alpha

This release introduces the first network-aware graph semantics on top of
RAHN's deterministic state engine.

Highlights

• Added first-class Interface objects owned by nodes.
• Links now connect (node, interface) endpoints.
• Added canonical state format v2.
• Added deterministic graph queries:
  • shortest path
  • neighbors
  • reachability
  • connected components
• Added connectivity isolation constraints with offending-path evidence.
• Made diff and merge interface-aware.
• Added regression coverage for graph-state edge cases.
• Added reproducible topology scaling benchmarks.

Architecture

The network model now moves beyond a generic state graph toward explicit
network semantics:

Node
  └── Interface
        └── Link Endpoint

RAHN v0.1.0-alpha.2 — Hardening & Research Foundation

RAHN v0.1.0-alpha.2

A hardening and research-foundation release following the initial
state-engine implementation.

Highlights

• Hardened the deterministic network-state engine.
• Expanded validation and regression coverage.
• Strengthened state integrity and verification behavior.
• Improved error handling and invalid-state rejection.
• Added the initial research and experiment structure.
• Added CI validation for the core workspace.
• Improved architecture, specification, and development documentation.
• Added licensing and contribution-policy foundations.

Architecture

This release stabilizes the initial RAHN state-engine foundation before
introducing network graph semantics in the next milestone.

The core remains focused on:

• deterministic state representation
• canonical serialization
• content-addressed state identity
• explicit state transitions
• semantic diff
• branching
• conservative merge behavior
• invariant verification
• verification-gated state changes
• simulation-only execution

Research Foundation

This release establishes the initial research corpus and experimental
structure that will be used to evaluate RAHN's architecture as it evolves.

The project is still experimental and does not claim production readiness.

Limitations

• No real network execution.
• No network graph semantics yet.
• No observability layer.
• No causal memory.
• No distributed state.
• No production network integration.

Next

v0.2.0-alpha — Network Graph Semantics