Your schema is your sync engine — a framework for collaborative, local-first apps.

Define your data once — sync, reactivity, validation, and persistence are derived from that single definition. Start on one machine with plain objects. Add peers, CRDTs, transports, and storage as you grow — without rewriting your app.

import { Schema, change } from "@kyneta/schema"
import { Exchange, sync } from "@kyneta/exchange"
import { loro } from "@kyneta/loro-schema"
import { createWebsocketClient } from "@kyneta/websocket-transport/browser"

// 1. Define your data
const TodoDoc = loro.bind(
  Schema.struct({
    title: Schema.text(),
    items: Schema.list(
      Schema.struct({
        text: Schema.string(),
        done: Schema.boolean(),
      }),
    ),
  })
)

// 2. Create an exchange, one per peer (or server/client)
const exchange = new Exchange({
  identity: { peerId: "alice" },
  transports: [createWebsocketClient({ url: "ws://localhost:3000/ws", WebSocket })],
})

// 3. Get a document — syncs automatically
const doc = exchange.get("my-todos", TodoDoc)

change(doc, d => {
  d.title.insert(0, "My Todos")
  d.items.push({ text: "Learn Kyneta", done: false })
})

doc.title()  // "My Todos"
await sync(doc).waitForSync()

React bindings are available today. It's easy to add other bindings.

import { useDocument, useValue } from "@kyneta/react"
import { TodoDoc } from "./schema.js"

function TodoApp() {
  const doc = useDocument("my-todos", TodoDoc)
  const title = useValue(doc.title)

  return (
    <div>
      <h1>{title}</h1>
      <button onClick={() => doc.items.push({ text: "New item", done: false })}>
        Add
      </button>
    </div>
  )
}

Every step below is additive — earlier code doesn't change.

See the @kyneta/exchange README for the full walkthrough with code.

Schemas should be walked once. A schema tree gets traversed for reading, mutation, observation, validation, sync, and more. Most frameworks implement these as parallel switch dispatches that drift apart. Kyneta's schema algebra collapses them into one catamorphism with pluggable interpreters — all behaviors are derived from the same structure. Your schema is the single source of truth not by convention, but by construction. Add a field and every behavior follows. There is nothing else to update.

Collaboration shouldn't require rewriting your app. Start with plain JS objects and createDoc(). When you need concurrent merge, swap to loro.bind() or yjs.bind() — reads, writes, and observation don't change. The exchange syncs documents via the Substrate interface — the exchange doesn't need to understand the inner workings of your CRDT library of choice. This is powerful, because you can mix collaborative CRDTs, authoritative json state, and ephemeral presence in one sync network.

Local-first means local first. Authority starts local — the hardest configuration to achieve, and the one you get for free. Centralize when your needs call for it. The network is additive, not load-bearing.

6,087 tests across the monorepo.

A plain JS substrate is built into @kyneta/schema — no external package needed to get started. These packages add CRDT backends:

@kyneta/changefeed                      (standalone — zero dependencies)
    │
    └──► @kyneta/schema                 (the algebra everything builds on)
            │
            ├──► @kyneta/loro-schema    (+ loro-crdt)
            ├──► @kyneta/yjs-schema     (+ yjs)
            │
            ├──► @kyneta/compiler       (+ ts-morph)   ── experimental
            │        └──► @kyneta/cast  (+ unplugin)    ── experimental
            │
            ├──► @kyneta/index          (+ changefeed; optional peer-dep: exchange)
            │
            └──► @kyneta/exchange       (+ transport)
                    │
                    ├──► @kyneta/wire   (+ tiny-cbor)
                    │        ├──► @kyneta/websocket-transport
                    │        ├──► @kyneta/sse-transport
                    │        ├──► @kyneta/webrtc-transport
                    │        └──► @kyneta/unix-socket-transport
                    │
                    ├──► @kyneta/leveldb-store
                    └──► @kyneta/react  (+ react)

@kyneta/machine                         (standalone — used by exchange, transports)
@kyneta/perspective                     (standalone — private, not published)

@kyneta/changefeed defines the universal reactive contract — the [CHANGEFEED] symbol protocol. @kyneta/schema builds the interpreter algebra on top of it. Everything else — substrates, exchange, transports, bindings — builds on schema's Substrate interface and changefeed's reactive protocol.

# Install dependencies
pnpm install

# Build all packages
pnpm build

# Run all tests
pnpm test

# Run tests for a specific package
cd packages/schema && pnpm test

These packages explore ideas at the frontier of the project. They are functional and well-tested, but represent research directions rather than stable APIs.

CRDTs already know what changed. When you insert a character, the CRDT emits a delta saying exactly where. Traditional UI frameworks ignore this — they diff output to rediscover changes. The compiler transforms natural TypeScript into code that directly consumes these deltas, achieving O(k) DOM updates where k is the number of operations. See the Kinetic status for details.

Traditional CRDTs couple state representation with merge logic. Perspective separates them: the semilattice moves to constraint sets, and a Datalog solver derives state. Conflict resolution strategies become rules that travel inside the data. See the Perspective README for the full treatment.

• Bananas, Lenses, Envelopes and Barbed Wire — Meijer, Fokkinga & Paterson, 1991. F-algebras, catamorphisms, and recursion schemes over algebraic data types. The theoretical basis for the schema interpreter algebra.
• CRDTs — Shapiro, Preguiça, Baquero & Zawirski, 2011. Conflict-free Replicated Data Types. The merge semantics behind Loro and Yjs substrates.
• DBSP — Budiu, McSherry, Ryzhyk & Tannen. Algebraic incremental view maintenance via Z-sets. Foundation for the compiler's incremental pipeline.
• Concurrent Constraint Programming — Saraswat, 1993. Theoretical ancestor of Perspective's constraint-based CRDTs.
• CALM Theorem — Hellerstein, 2010. Consistency as logical monotonicity.
• Datalog — Ullman, 1988. The query language powering Perspective's solver.

MIT — see LICENSE.