Events converge. Inevitably.
Aevrion is a paradigm for distributed data convergence. Every mutation is an immutable event on a temporal axis. No coordination. No leader. No consensus. Convergence is a property of the architecture, not a task for the operator.
Distributed systems diverge. The question is not if — it's how you detect and repair it.
Most systems treat anti-entropy as an operational burden: a scheduled job, a manual repair, a maintenance window. Aevrion treats it as a built-in primitive — continuous, automatic, and proportional to actual drift.
The foundation is one observation: time is the only coordinate you need for convergence.
The atomic unit. Three fields define identity: key, value, timestamp. The ID is blake3(key ‖ value ‖ timestamp) — content-addressable, immutable, verifiable.
Event {
key: "user:123"
value: { name: "Alice", role: "admin" }
timestamp: 1_710_684_600_042
id: blake3(key ‖ value ‖ timestamp) // derived
}
Same content on different nodes = same ID. No coordination needed.
Events are organized by time. Two parameters define the entire tree:
- G (granularity) — leaf size in milliseconds (default: 60,000 = 1 minute)
- B (branching factor) — children per node (default: 32)
Path from timestamp to leaf: leaf_id = timestamp / G. One integer division. Deterministic. No coordination.
level 4 │ ~1.9 years │ G × B⁴
level 3 │ ~22 days │ G × B³
level 2 │ ~17 hours │ G × B²
level 1 │ ~32 minutes │ G × B
leaves │ 1 minute │ G
5 levels cover 60 years. ≤160 hashes cover all history in one snapshot.
Nodes exchange tree snapshots every G. The closer to now — the more detail:
- Leaves — minute precision for the last ~32 minutes
- Level 1 — 32-minute blocks for the last ~17 hours
- Level 2 — 17-hour blocks for the last ~22 days
- Level 3+ — progressively coarser
Matching subtrees are skipped entirely. Repair cost is O(actual drift), not O(total data).
Bridge between the temporal axis (events by time) and the key axis (client queries by key). Maps key → latest event. Full history per key. Point-in-time queries. Fully derived — rebuilt from Event Store at any time.
Push (optimistic) → event sent immediately to neighbors
Snapshot (periodic) → progressive digest exchanged every G
Compare → hash mismatch = divergence pinpointed
Repair → chain reaction of handle() calls
Converged → same events, same state, deterministically
LWW conflict resolution. Higher timestamp wins. Tie: higher event ID wins. No version vectors. No merge functions.
- Append-only — events are never modified or deleted
- Temporal axis — time is the single organizing dimension
- Content-addressable — ID = hash of content
- Autonomous nodes — reads and writes never block on the network
- Full history — every version of every key, by design
- Eventual convergence — push (optimistic) + verify (pessimistic) = guaranteed
Aevrion — aevum (Latin: eternity) + -ion (Greek: particle).
A particle of eternity. Like photon, electron, graviton — a fundamental quantum that carries a force. An event is the quantum of change: the smallest, indivisible unit of mutation that travels through time and inevitably reaches every node.
This repository contains the aevrion.dev website — the conceptual overview of the Aevrion paradigm.
Apache 2.0