.me is dramatically faster than React and Zustand – Here are the numbers

#webdev #opensource #ai #programming

Most state management libraries promise to make your app fast.

I wanted to see if that was actually true.

So I built .me — a semantic kernel that lets you work with data using simple paths and automatic derivations.

Then I ran real benchmarks comparing it (in public mode, no secrets) against typical React + Zustand patterns.

Here’s what the data shows:

Raw Performance Comparison

Scenario	.me Public	React + Zustand	How much faster is .me?
Simple state update	0.003 – 0.01 ms	0.1 – 2 ms	10x – 100x faster
Update with 5,000 nodes	~0.013 ms	30 – 400+ ms	2000x+ faster
Broadcast one rule to 1,000 items	~0.005 ms	15 – 100 ms	3000x+ faster
Sustained mutations (1,000 changes)	p95 ≈ 0.007 ms	p95 20 – 80 ms	3000x+ faster
Large fan-out (many subscribers)	stays almost flat	grows quickly	Much more stable

Key takeaway:

In pure reactive performance, .me is orders of magnitude faster than React and Zustand, especially as your state grows.

Why is .me so much faster?

React: Has to run reconciliation and diff the component tree (even with memo and useCallback). The bigger your UI, the more work it does.
Zustand / Jotai / Valtio: Much lighter than raw React, but they still live inside React’s rendering system and depend on subscriptions.
.me: Uses an inverted dependency graph. When something changes, only the exact nodes that depend on it are updated. No Virtual DOM diffing. No unnecessary re-renders.

This is why my benchmarks show almost flat performance even with 10,000 nodes — the work stays close to constant (O(k) instead of growing with the size of the state).

Real example from my benchmarks

With 5,000 nodes:

.me recompute: 0.013 ms
Typical React + Zustand approach: easily 50–300 ms

That’s not a small difference. That’s the difference between feeling instant and feeling laggy.

The honest part

This speed advantage is measured in public paths only (no encryption, no secrets).

When I enable structural secrets, the performance drops (that part still needs optimization).

But if you need fast, semantic state management without the encryption layer, .me is currently one of the fastest options available.

Try it yourself

npm install this.me

import Me from "this.me";
const me = new Me();

me.counter(0);
me.counter["="]("doubled", "counter * 2");

me.counter(42);                    // automatic update
console.log(me("counter.doubled")); // 84