# Rindle

> One small engine that keeps your queries live — in the browser, in Node, over the network, or embedded in Rust. It takes over live queries, caching, and optimistic updates.

Rindle is an incremental view maintenance (IVM) engine written in Rust. You register a query once and it maintains the result as the data changes — computing the incremental difference on each write instead of re-running the query. One query API and one correctness contract (view-after-write == fresh-query) across every tier: an optimistic browser client (wasm), a stateless API authority, and an always-up `rindled` daemon.

## Product

- [Rindle — reactive queries, anywhere](https://rindle.sh/home.md): One small engine that keeps your queries live — in the browser, in Node, over the network, or embedded in Rust. Live queries, caching, and optimistic updates, handled by one engine.
- [Pricing — a flat company license, or managed Rindle Cloud](https://rindle.sh/pricing.md): The core engine is open source (Apache-2.0) and free to embed in anything you ship. Self-host the high-concurrency server under one flat company license sized by your team — never by cores — or let us run it for you on managed Rindle Cloud.
- [The AI track — agents on live data](https://rindle.sh/ai.md): Rindle streams cache-coherent semantic diffs to agents, coordinates them by subscription, and lets them branch reality before committing to it.
- [The UI track — the reactive database, on both ends](https://rindle.sh/ui.md): A reactive database in the browser, in your backend, or both: live queries into components, optimistic writes that rebase themselves, SSR, fragments, and local-only state.
- [The cache track — pin the query, delete the invalidation](https://rindle.sh/cache.md): Pin a query, read it one-shot from your API server, and share one materialization across every viewer. Cache speed, fresh-query correctness — no invalidation code.
- [The embedded track — the engine in your process](https://rindle.sh/embedded.md): A std-only Rust IVM core, ~200 kB gzipped as wasm — embed it in a binary, Node, or the browser, fold the raw delta stream, then scale the same queries onto a replicated read fleet.

## Start

- [What is Rindle?](https://rindle.sh/docs/overview.md): Rindle keeps your queries live with one engine — from a browser tab to a Node server to a synced, local-first app, behind one query language and one correctness contract.
- [Is Rindle for you?](https://rindle.sh/docs/compare.md): Who Rindle is for, what it replaces, how it compares to hand-rolled stacks, sync frameworks, hosted reactive backends, and warehouse-scale IVM — and the workloads it's wrong for.

## Build a synced app

- [Synced-app quickstart](https://rindle.sh/docs/synced-app-quickstart.md): Build a synced, local-first app end to end on one page: a SQL schema as the source of truth, generated TypeScript, an optimistic browser store, isomorphic mutators, your API authority, and the rindled daemon (self-hosted or on Rindle Cloud). Every file, every command.
- [Scaffold with create-rindle](https://rindle.sh/docs/create-rindle.md): Generate a SQL-first Rindle app on TanStack Start: browser client, API authority, rindled daemon, migrations, generated schema, SSR, and devtools in one template.
- [The three-tier architecture](https://rindle.sh/docs/architecture.md): How a synced Rindle app is wired — an optimistic browser client, a stateless API authority, and the always-up rindled daemon — plus the two planes and who is trusted with what.
- [Isomorphic mutators](https://rindle.sh/docs/mutators.md): One generator body per write, run on both tiers — the browser drives it synchronously as the optimistic prediction, the API server drives the same body into SQL as the authority. The op vocabulary, reads, the acting principal, and the determinism rules.
- [The browser client](https://rindle.sh/docs/client.md): createRindleClient gives the browser its own IVM engine over a local database — reads resolve instantly, writes apply optimistically and rebase, and rejections snap back on their own.
- [Agents on live data](https://rindle.sh/docs/agents.md): Wire an agent as another subscriber: named diffs in, salience-ranked digests out — the narrator registry over a view's own change channel, netted and per-view, on the same store your UI uses.
- [Compose the UI with fragments](https://rindle.sh/docs/fragments.md): Let each component declare the data it renders, then root the whole screen in one live coverage query with useRoot - no request waterfall.
- [The API server](https://rindle.sh/docs/api-server.md): Your app's authority — a stateless, serverless-shaped tier that authenticates the caller, resolves named queries to ASTs, drives the same isomorphic mutators the browser predicted into SQL, and keeps pinned queries warm for one-shot reads.
- [Server rendering](https://rindle.sh/docs/ssr.md): Preload named Rindle queries during SSR, dehydrate first-paint rows, hydrate the browser store, then hand off to the live wasm client without a flash.
- [Full app: the issue tracker](https://rindle.sh/docs/example-issue-tracker.md): A real issue tracker on all three tiers — rindled daemon, API server, optimistic React client — with paginated live windows over 5,000 issues and two live rejection paths. One command.

## The engine

- [How it works](https://rindle.sh/docs/how-it-works.md): The five-step lifecycle every crate shares — build a query, lower it into a graph, add a view, hydrate, push and flush — and why incremental beats recompute.
- [The change model](https://rindle.sh/docs/change-model.md): Two change vocabularies: SourceChange goes in, CaughtChange comes out — plus the change sink that delivers them and the replay-equivalence invariant.
- [Reactive queries in the browser](https://rindle.sh/docs/wasm-client.md): The dream API — a typed schema, a fluent query builder, and a live materialized view, all running on the IVM engine compiled to wasm, in-process in the browser.
- [Rust quickstart](https://rindle.sh/docs/quickstart.md): Stand up a live, incrementally-maintained SQLite query with the open engine — register a source, hydrate a view, and watch a write-through push update it by the delta.
- [Backends & the homes](https://rindle.sh/docs/backends.md): One engine, one query API, one correctness contract — over wasm in the browser, native SQLite in Node, or a server. The Backend seam that lets one view serve every tier.
- [Fold the delta stream yourself (Rust)](https://rindle.sh/docs/example-rust.md): The low-level home — attach a change sink and the open engine hands you the raw delta stream. Maintain your own view from the diffs alone, and prove it equals a fresh query.
- [Schema & migrations](https://rindle.sh/docs/schema.md): SQL is the source of truth. Define your tables in SQL, evolve them with additive migrations, and generate the typed schema your query builder needs — with one CLI: rindle migrate, rindle schema gen.

## High-concurrency runtime

- [The live-replica runtime](https://rindle.sh/docs/replica-and-views.md): The commercial runtime on top of the open engine: open a SQLite file, write ordinary SQL through one writer, and every live query streams back raw deltas — then scale it across readers with a thread pool or the daemon.
- [Run the daemon (rindled)](https://rindle.sh/docs/daemon.md): rindled — the always-on server you run like Postgres: the config, the two network planes, boot-id restart recovery, and the multi-threaded Cluster engine underneath.
- [Deploying & scaling Rindle](https://rindle.sh/docs/deploy.md): Rindle's one topology, from the colocated pair to a read-scaled fleet: an HCTree write-master, read-only followers, canonical backup, concurrent writes, and follower-affinity placement.
- [@rindle/cli](https://rindle.sh/docs/rindle-cli.md): The npm-installed Rindle toolchain: the rindle CLI, the supervised local rindled daemon, SQL migrations, generated TypeScript schema, and remote daemon commands.

## Rindle Cloud

- [Cloud quickstart](https://rindle.sh/docs/cloud-quickstart.md): Sign up, compose a stack, and provision a managed Rindle app in a few minutes — then point your code at it. The fastest path from zero to a running, durable Rindle backend you don't operate.
- [Connect your app to Rindle Cloud](https://rindle.sh/docs/cloud-connect.md): Point your API server and browser client at a managed Rindle Cloud app using the fleet, control, and write endpoints from the dashboard.
- [Scale & operate on Rindle Cloud](https://rindle.sh/docs/cloud-scaling.md): What the Rindle Cloud dashboard does after provisioning — read the converged topology, resize compute and storage, grow the read fleet, suspend and reactivate, and how usage-based billing works.

## Reference

- [Crates & API map](https://rindle.sh/docs/crates.md): What each crate owns, how they compose, and the API index — the map for navigating between the building blocks.
- [Supported query shapes](https://rindle.sh/docs/supported-queries.md): The honest matrix of what builds, pushes, and materializes today — written in the Rust rindle::table builder. The explicit list of what does not work yet.
- [Supported query shapes (TypeScript)](https://rindle.sh/docs/supported-queries-ts.md): The honest matrix of what builds, pushes, and materializes today — written in the @rindle/client TypeScript builder. The explicit list of what does not work yet.
- [Performance](https://rindle.sh/docs/performance.md): Why incremental maintenance is sub-microsecond and stays flat as data grows — measured end to end over a real dataset, plus a head-to-head against TanStack DB.
- [Devtools](https://rindle.sh/docs/devtools.md): Inspect a Rindle app in development: mutation timeline, live query inspector, raw delta stream, and the dev-only wiring for @rindle/devtools and @rindle/react-devtools.
- [Troubleshooting](https://rindle.sh/docs/troubleshooting.md): The rules that keep a Rindle app correct, and the ways an app goes subtly wrong when one is broken — sync that never starts, schema drift, optimistic flicker, silent writes, and auth smells, each with its fix.

## Blog

- [What Rindle Is For](https://rindle.sh/blog/what-rindle-is-for.md): An honest account of Rindle Cloud — the problems it's shaped for, the ones it isn't, and where the edges are. Written for someone deciding whether to build on it, not to sell them on it.

## Optional

- [Full text](https://rindle.sh/llms-full.txt): every page on this site concatenated into one Markdown document
- [Use the engine — one file](https://rindle.sh/llms-engine.txt): that docs path concatenated, in sidebar order
- [Build a synced app — one file](https://rindle.sh/llms-app.txt): that docs path concatenated, in sidebar order