ReactiveKit

The Full-Stack Framework for
Deterministic
Real-Time Distributed Systems

From data-processing pipelines to interactive UIs, ReactiveKit gives you the building blocks to compose robust, real-time distributed systems that are testable and debuggable by design.

Try it on GitHubLearn More

Always live data,
all the time

ReactiveKit abstracts away the complexity of subscriptions, callbacks and caches.

ReactiveKit’s full-stack reactivity primitives make stale data a thing of the past. Components throughout your architecture will always reflect the latest live updates, automatically and efficiently, with zero effort.

usePortfolioSummary.js (Server)
async function usePortfolioSummary(portfolioId) {
// Awaited values will live-update continuously
const holdings = await usePortfolio(portfolioId);
// All calculations will be recomputed when live values change
const prices = await Promise.all(
holdings.map(async (stock) => {
// Join on additional live values wherever you need them
const price = await useCurrentPrice(stock.symbol);
const exposure = price * stock.amount;
return { stock, price, exposure };
})
);
let total = 0;
for (const { exposure } of prices) { total += exposure; }
return { prices, total };
}
→
Portfolio Value
Live
$161,921.25
AAPL(300 shares)$202.82$60,846.00 ↗
MSFT(200 shares)$463.87$92,774.00 ↗
TSLA(25 shares)$332.05$8,301.25 ↘

Build systems that
explain themselves

ReactiveKit generates a complete causal history of every action.

Understand precisely why your system is in its current state, with every change automatically traced and linked.

1
Write declarative logic
Define what should happen, not how
2
Get automatic traceability
Every state change is causally linked
3
Debug with precision
Replay exact conditions and trace root causes
System Event Timeline
Paused
14:32:15.102Market data updated: AAPL $147.82
14:32:15.114Portfolio component recalculated
14:32:15.125Market data updated: AAPL $150.23
14:32:15.156Alert worker triggered: "High volatility"
14:32:15.167UI notification sent
14:32:15.145Portfolio component recalculated

Every message.
Every state change.
Completely deterministic.

Isolate any bug and trace every decision with perfect reproducibility.

Build with confidence, knowing your system’s behavior is predictable and reproducible.

$ rk-trace --type=message -n 5 --event-id=de0c9df4-eea9-4597-8da7-98cd1caf0673
14:32:15.091 PRICE_UPDATE { symbol: "AAPL", price: 147.81 }
14:32:15.102 PRICE_UPDATE { symbol: "AAPL", price: 147.82 }
14:32:15.125 PRICE_UPDATE { symbol: "AAPL", price: 150.23 }
14:32:15.156 ALERT_TRIGGERED { type: "VOLATILITY", symbol: "AAPL" }
14:32:15.178 NOTIFY_UI { alert: "High volatility", strategyId: "ecd9a69d-48a7-48b7-95e7-7e52da1d7766" }

Debug with surgical precision

  • ✓Replay any system state from any point in time
  • ✓Trace exact causal chains across distributed components
  • ✓Test edge cases with perfect reproducibility

A New Paradigm for Real-Time Systems

ReactiveKit offers a unified and simplified approach by combining three powerful building blocks.

Reactive Components
Define complex live computations
anywhere on your stack

Use cases:

  • • Dynamic front-end UI widgets
  • • Back-end streaming API endpoints
  • • Real-time dashboards
Scripted Workers
Stateful, repeatable
process orchestration

Use cases:

  • • Complex client-side form validation
  • • Data processing pipelines
  • • Alerting mechanisms
Intelligent Transport Layer
Deterministic, observable
system backbone

Key features:

  • • Ordered event bus synchronizes all interactions
  • • All application communication flows through this layer
  • • Single source of truth for deterministic system behavior

The combination of these three building blocks ensures that your system is always in sync,
allowing you to focus on building your application with confidence.

Deep-dive

Reactive Components

Define complex live computations anywhere on your stack

Reactive Components express a live computation, written as an async function.

The output of a Reactive Component can be a UI element, a streaming value to be exposed via an API, or any other serializable data structure, allowing the same components to be used interchangeably on both front-end and back-end.

Unlike the components you would typically encounter in UI frameworks, Reactive Components are managed by ReactiveKit’s runtime, enabling deterministic execution, efficient incremental re-computation, and causal logging across the entire stack.

Just use await keywords wherever you read from a live data stream, and ReactiveKit ensures it’s always up-to-date with the underlying data, automatically.

await calls can be chained to combine dependent data streams intuitively: ReactiveKit performs dynamic joining in the background, so nested dependencies stay synchronized without any manual coordination.

async function usePortfolioSummary(portfolioId) {
// Awaited values will live-update continuously
const holdings = await usePortfolio(portfolioId);
// All calculations will be recomputed when live values change
const prices = await Promise.all(
holdings.map(async (stock) => {
// Join on additional live values wherever you need them
const price = await useCurrentPrice(stock.symbol);
const exposure = price * stock.amount;
return { stock, price, exposure };
})
);
let total = 0;
for (const { exposure } of prices) { total += exposure; }
return { prices, total };
}
Declarative & Composable

Focus on the "what", not the "how". Build up arbitrarily complex component logic, while ReactiveKit keeps everything in sync.

Efficient Updates

Built-in intelligent dependency caching ensures only the outputs that have changed are re-evaluated, ensuring your application stays performant at scale.

Truly Full-Stack

Use the same familiar syntax to build dynamic user interface elements on the front-end, and to define reactive data transformations and pipelines on the backend.

Deep-dive

Scripted Workers

Stateful, repeatable process orchestration

Scripted Workers are composable runners for deterministic procedural workflows,
suitable for both short-lived one-off tasks and long-running event-driven services.

Scripted Workers provide a structured way to orchestrate multi-step operations, ensuring each step is executed according to strict logical rules. This makes them ideal for anything from data processing pipelines to user interaction flows.

Build complex workflows using powerful control flow primitives for operation sequences, conditional branching, iterative loops, internal state management, and message-passing communication.

Determinism is enforced by operating solely on input messages and internal state, with all side effects mediated via the Intelligent Transport Layer to ensure perfect replayability.

export default act((self, { outbox, complete, fail }) =>
sequence(() => [
waitFor(
(msg) => msg.type === 'EXECUTE_TRADE',
(msg) => send(LedgerService, readState(msg, ({ payload }) => ({
type: 'EXECUTE_TRADE',
...payload
})))
),
waitFor(
(msg) => msg.type === 'TRADE_SUCCESS' || msg.type === 'TRADE_FAILED',
(msg) => whenState(
readState(msg, ({ type }) => type === 'TRADE_SUCCESS'),
send(NotificationService, readState(msg, ({ payload }) => ({
type: 'NOTIFY',
message: 'Trade executed successfully',
...payload,
}))),
sequence(() => [
send(NotificationService, readState(msg, ({ payload }) => ({
type: 'NOTIFY',
message: 'Trade failed',
...payload,
}))),
fail()
])
)
),
complete()
])
);
Declarative & Composable

The intuitive declarative API and powerful logic combinators make it simple to build up clear, testable, and maintainable logic.

Deterministic Stateful Logic

Define synchronous and asynchronous workflows step-by-step, ensuring predictable, testable behavior and state transitions.

Message-Driven Communication

Interact with other workers and components via a simple actor-style message-passing API that integrates with ReactiveKit’s transport layer.

Deep-dive

Intelligent Transport Layer

Deterministic, observable system backbone

All ReactiveKit interactions and data pass through a central event bus, producing an ordered event log with full causal traceability.

This layer is the fundamental backbone of your ReactiveKit application. More than just a record of events, the event bus effectively drives the system: new entries automatically trigger actions in Reactive Components and Scripted Workers, ensuring a logically consistent reactive system.

ReactiveKit’s transport layer correlates the event logs from distributed ReactiveKit instances, providing a unified view of system-wide operations even when services span different processes or machines.

This transport layer can be easily extended with middleware to provide complex logging, observability, recording, and more. This leads to a truly deterministic, observable, and debuggable system.

Reactive Components

Event Bus Messages

Scripted Workers

Side Effects

Portfolio Widget
Alert Dashboard
UPDATE_PORTFOLIO
INPUT_VALIDATED
EXECUTE_ORDER
ORDER_EXECUTED
FETCH_REQUEST
FETCH_RESPONSE
RISK_ALERT
ORDER_PLACED
PORTFOLIO_UPDATED
Input validation
Order Executor
Send notification
Exchange API
Sequence diagram showing interactions with the Intelligent Transport Layer event bus within a ReactiveKit system

Batteries included

ReactiveKit is built upon a highly pluggable architecture,
allowing you to extend its capabilities or integrate with your existing stack.

Available now
Key building blocks for kicking the tires
  • ReactiveKit core bundle
  • HTTP Fetch
  • State management utilities
  • Timers (including retry/backoff)
  • Custom extension SDK
Next milestone
All-in-one app development toolkit
  • File System utilities
  • WebSocket transport
  • SSE transport
  • GraphQL (Client & Server)
  • gRPC (Client & Server)
  • Event log CLI
Future integrations
Integrate with your wider infrastructure
  • SQL (Postgres, MySQL)
  • NoSQL (MongoDB, Redis)
  • NATS transport
  • Kafka transport
  • Kubernetes orchestration

Leverage a growing library of official plugins, or even write your own.

Why Choose ReactiveKit?

Simplified Development

Focus on building, not plumbing.

Drastically reduce boilerplate for state synchronization, concurrency, and async logic.

Inherently Robust

Built for reliability from the ground up.

Fully reactive dataflow guarantees consistent behavior across your system, making sure it never falls out of sync.

Deterministic by Design

Perfectly reproducible behavior for a given sequence of external inputs.

Build real-time systems you can trust to behave predictably and reproducibly.

Causal Event Log

Every message, interaction, and state change forms an ordered, traceable history.

Replay any event sequence to verify behavior or diagnose issues.

Radically Testable

Architected for testing at every level.

ReactiveKit test utilities make it easy to write comprehensive tests with confidence, from individual units to complex interactions.

Precision Debugging

Trace exact event sequences to diagnose issues or verify behavior.

Untangle complex edge cases with an unprecedented view into your system’s causal history.

Built-in Record/Replay

Never miss an edge case.

The event log enables recording and replaying system interactions for in-depth debugging, regression testing, or scenario analysis.

Distributed Observability

Visualize your entire system.

Gain insights into how different components of your distributed ReactiveKit system interact, even across service boundaries.