The ledger settles.

Many timelines arrive.

seed: 0x000000 click to reseed
II · settled events

The past, recorded on stone.

    II · in-flight

    The present, still arriving.

      Begin a simulation
      III · reconciliation

      Two timelines, one floor.

      01

      A write arrives twice. The ledger keeps its first opinion.

      When two replicas issue the same effect inside a single tick, the engine retains the lower-ordered identity and folds the duplicate into a no-op. The history reads as if the second arrival had always agreed.

      02

      A speculative fork retires when its parent settles.

      Branches drawn from a still-pending event do not vanish; they wait against the meridian until their parent is reconciled, and then merge with the canonical line in a single deterministic step.

      03

      Out-of-order delivery is not a defect; it is the medium.

      The engine treats arrival order as advisory. A canonical timestamp is computed from a hybrid logical clock and re-asserted at every settlement boundary, so wall-clock skew never bleeds into the recorded history.

      04

      A test that runs twice on the same seed is the same test.

      Determinism is a property of the engine, not a configuration of it. Given an identical seed and an identical scenario, every clock, every grain of paper, every retried fork resolves to the same byte. We do not record what we cannot reproduce.

      05

      Failure is recorded with the same dignity as success.

      When a participant defects mid-tick, the engine does not retry quietly. The defection is written into the ledger as an event in its own right, and downstream readers of the timeline can see precisely where the fork diverged from the floor.

      IV · benchmarks

      A horizon made of digits.

      The far ridge in this chapter is not a ridge. It is a column of measurements, set so that the baseline of each digit traces the silhouette of a distant range. Hover the ridge to read it as data; otherwise it remains scenery.

      tickevents / sp50 (µs)p99 (µs)
      V · documents

      A patient instrument.

      The engine speaks one verb — reconcile. Every other operation is a particular flavor of reconciliation: a write is the reconciliation of an empty cell with a value; a retry is the reconciliation of two attempts at the same identity; a snapshot is the reconciliation of a moving floor with a stationary observer.

      The API surface is small on purpose. There are four entry points, two of which are inverses, and a single observation channel that streams the canonical history in the order it settled, never in the order it arrived.

      # reconcile two events into the canonical floor
      use concengine::{Engine, Event, Seed};
      
      let mut engine = Engine::with_seed(Seed::from_hex("0x55d9e598"));
      
      engine.tick(0, [
          Event::write("ledger/01", "settled"),
          Event::write("ledger/01", "settled"),
      ]);
      
      for e in engine.history() {
          println!("{:08} {} {}", e.index, e.id, e.payload);
      }
      
      VI · provenance

      Hands that left fingerprints.

      No photographs. No titles. Just names, set on paper, with a small mark for the kind of work each contributed to the ledger.

      • Ines Adamou
      • Hyun-jae Park
      • Tomas Levenfeld
      • Maeve Okonkwo
      • Salomon Vrede
      • Anastasia Pelaez
      CE
      Built on aged paper. · Settled deterministically. · © concengine · build 0x55d9e598