Ripple-Reactive

Roadmap & Future Scope

What's coming next for Ripple.js.

Ripple.js was conceived with a clear vision: bring fine-grained, glitch-free reactive primitives to every JavaScript environment with zero framework lock-in.

Following the initial release of core primitives, collections, stores, and framework adapters, our roadmap outlines upcoming milestones, architectural enhancements, and ecosystem tooling.

v0.2.0 (Next Minor)

The v0.2.0 cycle focuses on developer ergonomics, asynchronous reactivity, and visual inspection.

Fine-Grained selector() for Stores

Borrowing the best ideas from modern state management, selector() will enable fine-grained property selection with shallow comparison. This prevents unnecessary re-evaluations when unrelated store slices update.

// Planned API Preview
import { createStore, selector } from 'ripple-reactive';

const store = createStore({
  state: {
    user: { name: 'Alice', age: 30 },
    settings: { theme: 'dark' },
  },
});

// Re-evaluates ONLY when user.name changes
const userName = selector(store, (state) => state.user.name);

Async Computed Values

While resource() covers parameter-driven async fetching, async computeds will allow computed() to directly return Promises with built-in suspension tracking and race-condition prevention.

// Planned API Preview
import { signal, computed } from 'ripple-reactive';

const query = signal('ripple');

const searchResults = computed(async () => {
  if (!query.value) return [];
  const res = await fetch(`/api/search?q=${encodeURIComponent(query.value)}`);
  return res.json();
});

RxJS Interoperability

First-class bidirectional conversions between Ripple.js signals and RxJS Observables. toObservable() and fromObservable() allow complex stream operators to pipe into reactive signals.

// Planned API Preview
import { signal, toObservable, fromObservable } from 'ripple-reactive';
import { filter, map } from 'rxjs/operators';

const count = signal(0);
const count$ = toObservable(count);

const evenDoubles$ = count$.pipe(
  filter((n) => n % 2 === 0),
  map((n) => n * 2)
);

const evenDoubleSignal = fromObservable(evenDoubles$, 0);

DevTools Browser Extension

A dedicated Chrome and Firefox extension paired with a standalone web inspector:

  • Reactive Dependency Graph Visualization — view upstream and downstream nodes in real time
  • Dirty Notification Inspector — watch update propagation waves traverse the graph
  • Timeline and State History — time-travel through signal mutations and undo/redo operations

v0.3.0 (Future)

The v0.3.0 release targets multi-threaded execution, distributed runtime environments, and enterprise store extensions.

Server-Side Rendering (SSR) and Hydration

  • Isolated, request-scoped signal graph instances to prevent cross-request memory leaks in Node.js and Bun servers.
  • Safe client hydration: serialize initial signal snapshots from the server and hydrate reactive graphs on the client without duplicate effect triggers.

Cross-Context channel()

A reactive pub/sub primitive backed by the browser BroadcastChannel API and Web Workers. Changes to a channel signal automatically propagate across browser tabs, windows, and workers.

// Planned API Preview
import { channel } from 'ripple-reactive';

// Synchronized across all open tabs in real-time
const activeSession = channel('user-session', { activeTabId: 'main' });

Middleware System for Stores

Extensible middleware hooks for createStore(), unlocking community plugins:

  • Logging and Telemetry — action time tracking, state diffing, and crash reporting
  • Schema Validation — enforce schemas at runtime using Zod or Valibot on every state transition
  • Storage Sync — universal sync with IndexedDB, Web Storage, or remote backends

Web Worker Offloading for Heavy Computeds

Automatic offloading of CPU-intensive computed calculations to background Web Workers using transferable objects, keeping main UI threads stutter-free at 60+ FPS.

v1.0.0 (Stable)

The v1.0.0 milestone marks production maturity, ironclad stability, and enterprise readiness.

API Stabilization and SemVer Guarantee

  • Final freeze on core primitive interfaces (signal, computed, effect, batch).
  • Strict semantic versioning adherence: zero breaking changes within major versions.

Comprehensive Framework Migration Guides

Detailed guides, comparison tables, and automated migration codemods for teams migrating from:

  • @preact/signals
  • @vue/reactivity
  • solid-js

Official React Server Components (RSC) Support

Seamless compatibility with modern React architectures, including Next.js App Router and streaming SSR components.

100% Test Coverage and Fuzz Testing

  • Comprehensive test suite reaching 100% branch and statement coverage.
  • Automated stress-testing of cyclic graph detection, intrusive linked-list memory pooling, and garbage-collection pressure.

Get Involved

We value your input! Ripple.js is community-driven. If you have feedback on proposed APIs, feature requests, or would like to contribute an RFC, join the discussion on GitHub.

On this page