A new open-source reactive engine, .me from neurons.me, claims to achieve microsecond-scale data propagation for complex graph structures by replacing traditional Signals and Observables with flat semantic key-value maps. Benchmarks show 22,294 events per second with per-event resolution latency of just 0.045 milliseconds, avoiding the proxy wrappers and memory leaks that plague fine-grained reactivity at scale.
The Scalability Problem with Signals and Observables
Signals and Observables have become the standard for fine-grained reactivity in modern frontend frameworks like Preact, SolidJS, Angular, and Vue. They work well for linear UI updates such as toggling a modal or validating a single form field. However, when applied to complex, relational graph data structures — real-time geospatial tracking, peer-to-peer social meshes, or multi-agent simulations — their core assumptions break down.
Traditional reactive patterns require wrapping primitive values in Proxy objects or dynamic containers. Scaling to hundreds of thousands of relational nodes destroys JavaScript engine optimizations, inflating memory usage and triggering severe garbage collection pauses. Computed values that depend on multiple dynamic variables force runtime subscription tracking, leading to exponential dependency tracing overhead and hard-to-debug circular reference deadlocks. In dynamic graphs where nodes are added or removed frequently, a single forgotten unsubscription can hold an entire branch in memory, causing fatal leaks.
Flat Semantic Keys Enable O(k) Propagation
The .me engine sidesteps these issues by decoupling reactivity from object nesting entirely. Instead of nested proxy trees, it uses a flat key-value map where data paths are stored as flat strings — for example, `affinity.targets.2.score` or `users.pablo.isAdult`. This layout enables immediate O(1) hash-map lookups directly in memory.
When a variable changes, the engine relies on hardcoded dependency metadata (`dependsOn`) generated at the node's origin. Rather than dynamically discovering what changed at runtime, it performs a precise O(k) deterministic jump across memory boundaries, where k is the explicit number of downstream nodes bound to that mutation. This keeps resolution complexity strictly bound to k instead of the total data matrix size N, which can reach up to 1,000,000 active keys.
Context-Aware Node Resolution
Standard reactivity frameworks evaluate expressions globally, assuming a value means the same thing to every consumer. The .me engine supports Context-Aware Policies, where data changes its operational meaning based on the consumer's environment. For example, in a robotics simulation, multiple autonomous agents (Loader, Nurse, Surgeon) can point to the same physical asset (`objects.canister7`). As the asset's attributes change — such as sterilization status — the downstream reaction is evaluated through each robot's unique context.
The system automatically resolves deep dependency trees across different domains, from physical object tracking to safety constraints, updating complex authorization states in real time without manual sync steps. Developers no longer need to compromise between fine-grained reactivity and memory efficiency, scaling data layers to millions of interdependent elements with predictable runtime performance on client hardware.
The engine is open-source and available on GitHub for production testing.