v0.9.4
Global Mesh: 28 PoPs Active99.999% DETERMINISM SLA
Programmable Execution InfrastructureNo Orchestrator Lock-in
Modern distributed applications need distinct guarantees: determinism, instant replay, and speculative branching. useEventStack is the code-first runtime that turns arbitrary application logic into durable, verifiable, reversible execution DAGs without workflow DSL lock-in.
explainer-60s.en.mp4 · 1280×720 · 60s · neural narration
60-SECOND EXPLAINERHD
60-second tour
The same chapters are embedded in the player.
Multi-Runtime Quick Install
curl -fsSL https://get.useeventstack.dev | sh
Section 01 // The Problem
Building reliable systems today means choosing between brittle ad-hoc glue code, bloated black-box workflow orchestrators, or massive vendor-locked cloud state machines.
Partial network partitions, split-brain payments, and third-party rate limits leave microservices in inconsistent zombie states. Developers end up hand-coding retry loops that exacerbate cascading stampedes.
State drifting across DB + Queues
Traditional orchestrators require heavy proprietary servers, specialized JSON/YAML DSLs, and invasive decorators that completely contaminate your core business domain models.
Heavy background worker overhead
Modern pipelines combine LLMs, external APIs, and local state. When an LLM takes 4 seconds or times out, you cannot afford to restart from scratch or leave users waiting without fallback speculation.
Inability to branch speculative paths
Section 02 // The Core Idea
In useEventStack, your code defines what happens. You attach execution semantics as pure composable policies. The runtime handles idempotency, state persistence, replay journals, and speculative resolution.
Layer 01
Pure async functions, business entities, and domain handlers. Zero orchestration bloat.
TypeScript / Rust / Go
Layer 02 (new)
Deterministic replay, transactional outbox, speculative concurrency, isolated journals.
Configurable per step / pipeline
Layer 03
Lightweight embedded engine (<4MB memory). Checkpoint journal and DAG scheduler.
Local / MicroVM / Node Process
Layer 04
Postgres, Redis, FoundationDB, S3, or Edge KV. Bring your existing persistence layer.
Pluggable Storage SPI
Section 03 // Code-First Philosophy
You don't need drag-and-drop workflow canvases or JSON diagrams to achieve high reliability. With useEventStack, write idiomatic code in native languages. Every call chain is recorded to a deterministic Merkle state tree.
// Import execution primitive without daemons
import { defineStack, step } from "@eventstack/core";
export const checkoutEngine = defineStack({
name: "ecommerce.checkout",
semantics: {
durability: "checkpoint_each_step",
onFailure: "replay_from_last_known_good",
}
})
.step("verifyInventory", async ({ payload, db }) => {
return await db.inventory.hold({ sku: payload.sku, qty: payload.qty });
})
.speculativeStep("processPayment", {
branches: {
primary: async (ctx) => ctx.stripe.charge(ctx.input.token),
backup: async (ctx) => ctx.adyen.authorize(ctx.input.token)
},
resolveStrategy: "fastest_successful"
})
.step("emitOrderPlaced", async ({ results, bus }) => {
await bus.publish("order.completed", results);
});Section 04 // Strategy Matrix
Select the optimal strategy per operation, or combine them in a single workflow pipeline.
DETERMINISTIC
Every step input, side-effect output, and timer is recorded to an append-only journal. Re-executing produces bit-for-bit identical state every time.
REPLAY SEMANTICS
Reconstruct any historical system state by replaying journals. Debug production bugs locally by injecting real production event traces into your local simulator.
SPECULATIVE
Spawn parallel execution hypotheses concurrently. Discard failed or slow branches with zero journal pollution while committing the winning result atomically.
Section 05 // Speculative Execution
Distributed systems face latency spikes, unpredictable AI agent outputs, and flaky external APIs. Instead of waiting sequentially, execute multiple hypotheses in isolated temporary sandboxes.
Section 06 // Universal Footprint
useEventStack doesn't demand Kubernetes or a managed SaaS orchestrator. The runtime compiles down to native machine code or WebAssembly and runs anywhere computing happens.
| Environment | Binary Size | Cold Start | Persistence SPI |
|---|---|---|---|
| Node.js / Bun | 3.4 MB | 8 ms | Postgres / Redis / FS |
| Rust Native | 2.1 MB | 0.8 ms | RocksDB / SQLite / S3 |
| Wasm Edge | 1.2 MB | 1.4 ms | KV Storage / Durable Objects |
| Docker Container | 18 MB (Scratch) | 22 ms | Any JDBC / Raft Store |
Section 07 // Architecture Flexibility
useEventStack doesn't require rewriting your existing backend services. It embeds directly inside your microservices, APIs, background queues, or event routers.
Wraps consumer handlers with automatic step checkpointing. Never double-process a duplicate message.
Handle brittle 3rd-party webhooks with automatic exponential replay and zero state loss.
Guarantees that database writes and outgoing network events commit atomically.
Checkpoint multi-step tool calls and branch alternate agent prompts speculatively.
Section 08 // Wire-to-Storage Architecture
Comprehensive wire-to-storage breakdown of the useEventStack kernel. Pure deterministic contracts between the user application and storage drivers.
Ingestion
gRPC / HTTP / Kafka / SQS. Ingests raw event and assigns logical clock timestamp.
Isolation
Sandboxes side-effects. Intercepts random seeds, clocks, and external I/O.
Core engine
Merkle State DAG, Speculation Switcher, Replay Controller, Outbox Manager.
Journaling
Zero-loss WAL journal. Snapshot intervals with atomic pointer swap.
Targets
Databases, external APIs, and pub/sub queues receive committed mutations.
Section 09 // Developer Experience Flow
01 // Install
Run npm i @eventstack/core or cargo add use-event-stack. No external server daemon required.
02 // Define
Assign execution strategies (replayable, speculative, deterministic) to functions via declarative type-safe builders.
03 // Simulate
Use the embedded test simulator to inject packet drops, timeouts, and process kill signals without leaving localhost.
04 // Recover
Export encrypted production journal traces and step through execution locally in VS Code with full breakpoint support.
Section 10 // Formal Correctness & Verification
Execution infrastructure cannot fail silently. We subject useEventStack to rigorous formal verification, chaos injection, and Jepsen test suites.
TLA+ Specification
The Merkle replay kernel and speculative rollback algorithms are verified against state-space explosion using TLC Model Checker.
Jepsen Audited
Verified under continuous network drops, process kills (kill -9), and storage disk fsync failures without silent corruption.
Deterministic Clocks
Clocks, timeouts, and sleep durations are virtualized into logical ticks, enabling 10-hour timeouts to be tested in 2 milliseconds.
Section 11 // Target Personas
01
Standardize company-wide resilience without mandating heavy proprietary clusters.
02
Replace spaghetti retry logic and brittle cron jobs with durable deterministic pipelines.
03
Ingest flaky webhooks and sync partner ERP systems with zero transaction drop.
04
Establish verifiable system invariants with audit-ready cryptographic journals.
05
Drastically reduce cloud spend and operational incidents while avoiding orchestrator lock-in.
Section 12 // Real-World Production Use Cases
Financial commerce
Speculatively execute primary and secondary payment authorization paths to hedge against payment gateway brownouts, reducing checkout drop-offs by 4.2%.
Data pipelines
Stream database changes through deterministic transformation pipelines. When downstream destination DBs crash, resume exactly at the committed Merkle offset.
AI agent platforms
Branch queries concurrently across local small language models and cloud frontier models. Commit the first response that passes deterministic validation schema.
Section 13 // Open Source & Research
We publish our architectural RFCs, formal TLA+ proofs, and engine specifications openly for community critique and peer review.
RFC-0081
Specifies clock mocking and monotonic tick incrementing across asynchronous distributed runtimes.
View Specification →RFC-0083
Defines sandboxed journal partitioning and O(1) rollback guarantees for concurrent speculative tasks.
View Specification →RFC-0087
Cryptographic hash tree verification for zero-copy state reconstruction and production time-travel debugging.
View Specification →Questions, answered
Short, direct answers — the same text search and AI engines cite.
useEventStack is a code-first execution runtime that turns ordinary application logic into durable, verifiable, reversible execution DAGs. You write native TypeScript, Rust, or Go — the runtime adds determinism, instant replay, and speculative branching without a workflow DSL or orchestrator lock-in.
Workflow engines require proprietary servers, JSON or YAML DSLs, and decorators that invade your domain code. useEventStack embeds inside your existing services as a lightweight runtime under 4MB, keeps your code idiomatic, and makes execution semantics — deterministic, replayable, speculative — a per-step configuration instead of a platform migration.
Deterministic execution records every step to an append-only journal for bit-for-bit reproducible state. Time-travel replay reconstructs any historical state for debugging and audits. Speculative branching runs parallel execution hypotheses and commits the winner atomically, discarding slow or failed paths with zero journal pollution.
When a trigger arrives, the runtime snapshots state and executes multiple hypotheses — for example a cached embedding, a live LLM call, and a rules heuristic — in isolated sandboxes. An evaluator picks the winner, which commits atomically while losers roll back with a pure O(1) pointer swap.
Anywhere computing happens: cloud pods and serverless functions with sub-12ms cold starts, WebAssembly edge workers across 28 global PoPs, or self-hosted bare metal with full air-gapped support. Persistence is pluggable — Postgres, Redis, RocksDB, SQLite, S3, or edge KV.
A 1.18ms p99 journal sync with zero dropped writes, an 8ms cold start on Node.js and 0.8ms on native Rust, and a 99.999% determinism SLA backed by TLA+-verified invariants and Jepsen-tested partition recovery.
One command — curl -fsSL https://get.useeventstack.dev | sh — or install for Cargo, npm, Homebrew, or Docker. The runtime is open source under Apache-2.0 and MIT, and the multi-runtime quick-install on this page gets you running in about 60 seconds.
READY FOR ENTERPRISE WORKLOADS
Eliminate zombie states, avoid orchestrator lock-in, and gain full determinism across all your services.
curl -fsSL https://get.useeventstack.dev | sh
Apache-2.0 & MIT Dual License • Open Source Runtime
Start Building NowStar on GitHub (4.2k)