Rust .me Benchmarks

This directory contains the Rust benchmark ground for the .me kernel port.

The benchmarks are executable binaries, not hard regression thresholds. Their job is to keep the kernel honest while the Rust implementation catches up to the TypeScript semantic contract: append-only memory, path selectors, reactive derivations, secret scopes, lazy/eager recomputation, traceability, hydration, and public/owner projections.

Always run them in release mode:

cargo run --release --bin <benchmark-name>

Coverage

Commands

cargo run --release --bin bench-ok
cargo run --release --bin bench-sustained
cargo run --release --bin bench-fanout
cargo run --release --bin bench-cold-warm
cargo run --release --bin bench-explain-overhead
cargo run --release --bin bench-secret-scope
cargo run --release --bin bench-push-pull
cargo run --release --bin bench-secret-push-pull

Reading The Results

k is the semantic recompute wave size. It should track the number of actual dependent targets touched by a write or fresh read, not total memory size.

Public hot paths should stay very small. Secret paths are expected to cost more on write because stored memories are encrypted, but owner reads can remain cheap while the live owner index is hydrated.

Lazy mode does not mean “free write.” It still marks dependent derivations stale. The win is that it avoids recomputing every subscriber until a fresh read actually asks for a target.

Run #001

this-me v0.3.0 · Aug 26, 2026 · 4:37 PM CST · Suis-MacBook-Air.local

Release mode command:

for bin in bench-ok bench-sustained bench-fanout bench-cold-warm \
  bench-explain-overhead bench-secret-scope bench-push-pull \
  bench-secret-push-pull; do
  cargo run --release --bin "$bin"
done

1. O(k) Recompute Isolation

Irrelevant public nodes do not affect the recompute wave. k stayed at 1 while total memories grew past 10,000.

2. Sustained Mutation

2,000 consecutive mutations over 4,000 nodes stayed stable. p95 drift was negative in this run, meaning the late window was faster than the first window.

3. Fan-Out Sensitivity

This benchmark intentionally changes the number of real dependents. The wave size tracks actual subscribers (k = fanout), not unrelated memory.

4. Cold vs Warm Runtime

Snapshot hydration scales with memory count and is paid at startup. Warm mutation remains tiny after hydration.

5. Explain Overhead

explain() is cheap enough to keep derivations inspectable. The measured baseline was noisier than the explain run here, so the meaningful number is explain_only: p95 around 0.52ms for a 3,000-node derivation wave.

6. Secret Scope Impact

Secret direct write/read is slower than public write/read, as expected, but it is still sub-0.04ms at p95 in this run. Lazy derivation cost was close to public.

Write/read p95 slowdown: 447.95%. Lazy derivation p95 slowdown: 9.55%.

7. Push vs Pull

Eager mode pays on mutation. Lazy mode keeps mutation small and defers subscriber recompute until read.

8. Secret Push vs Pull

Lazy public and secret branches remain in the same broad performance envelope for the measured node counts.

Current State

Run #001 confirms the Rust port is past boilerplate: it has measurable, release-mode behavior across public writes, selectors, derivations, hydration, secret scopes, lazy/eager recompute, and explainability.

The strongest current signal is not “Rust is faster everywhere.” The honest signal is better: Rust already preserves .me’s semantic shape while giving the kernel an embeddable, memory-safe host suitable for monads, local daemons, robots, Raspberry Pi-class machines, and edge runtime work.

The Rust implementation is allowed to improve internal mechanics, but it should not change .me meaning to chase a number.