Gradio

Pick a strategy. Merge two models. See the mathematical proof that merge(A,B) == merge(B,A). Uses real prajjwal1/bert-tiny weights from HuggingFace Hub when available, otherwise synthetic tensors.

Note: Some strategies may produce similar or identical outputs with only 2 models at equal weights — this is mathematically expected. Differences become significant with 3+ models or real fine-tuned weights.

Merge Strategy

26 strategies. Task-vector strategies (ties, dare, etc.) use a synthetic base.

Model A Weight (Model B = 1 − A)

0.1 0.9

Attention Weight Heatmap — Model A | Model B | Merged

Layer Contribution Map

Per-Layer Provenance

Every strategy tested live against all three CRDT laws — commutativity, associativity, idempotency. The two-layer OR-Set architecture makes any strategy CRDT-compliant without modifying the strategy itself.

CRDT Compliance — All 26 Strategies

Full Compliance Matrix

Full Compliance Matrix

The Mathematical Proof — Naive vs crdt-merge

Standard merge strategies fail associativity: merge(merge(A,B), C) ≠ merge(A, merge(B,C)). crdt-merge's OR-Set layer absorbs this — the gap drops to exactly 0.0 for every strategy.

Associativity Verification

Naive vs crdt-merge Associativity Gap

Real benchmark results from NVIDIA A100-SXM4-40GB · v0.7.1 · Python 3.12. Polars engine peak: 38.8× speedup over Python at 500K rows. Streaming merge: O(1) memory verified — throughput dead-flat from 100K to 5M rows.

Python vs Polars Throughput

Polars Speedup Factor

CRDT Primitive Throughput

Streaming Merge — O(1) Memory

Raw Benchmark Data (A100 v0.7.1)

Raw Benchmark Data (A100 v0.7.1)

10,000,000	219K/s	6.8M/s	32.8×

Raw Benchmark Data (A100 v0.7.1)

10,000	219K/s	42K/s	0.2×
50,000	207K/s	6.8M/s	32.8×
100,000	225K/s	8.3M/s	37.0×
500,000	217K/s	8.4M/s	38.8×
1,000,000	225K/s	7.9M/s	35.2×
5,000,000	223K/s	5.0M/s	22.5×
10,000,000	225K/s	4.8M/s	21.4×

Explore the architecture layers, distributed protocols, and domain-specific merge capabilities.

Two-Layer Architecture — The Key Innovation

┌──────────────────────────────────────────────────────────────────────┐
│  LAYER 1 — OR-Set CRDT State (CRDTMergeState)                       │
│                                                                      │
│  Contributions arrive in ANY order from ANY node                     │
│  OR-Set union: commutative + associative + idempotent by definition  │
│  Every contribution: content-addressed (SHA-256 Merkle hash)         │
│  Version vectors for causal ordering                                  │
│  Tombstones for safe remove/replace operations                        │
│                                                                      │
│  merge(state_a, state_b) → set union  ← CRDT laws guaranteed here   │
└──────────────────────────────────────────────────────────────────────┘
                               │  resolve() — applied atomically
                               ▼
┌──────────────────────────────────────────────────────────────────────┐
│  LAYER 2 — Strategy Execution (pure function over sorted set)        │
│                                                                      │
│  Sees a SET — ordering non-determinism completely absorbed           │
│  26 strategies: weight_average, slerp, ties, dare, fisher, dual_     │
│    projection, evolutionary, negative, safe_merge, and 18 more ...   │
│  Same inputs → always same output (determinism via canonical sort)   │
│                                                                      │
│  f(sorted_set_of_contributions) → merged_tensor                     │
└──────────────────────────────────────────────────────────────────────┘

Why this works: Layer 1 guarantees all replicas converge to the same set of inputs. Layer 2 guarantees the same set → same output. Together: full CRDT convergence for any strategy.