concord

Apps that don't store state. They replay it.

Concord is a runtime for building applications where state is derived from signed, append-only history. Dispatch commands. Commit intentionally. Encrypt sensitive payloads client-side. Replay history into state. The result is a portable, verifiable document instead of a mutable app database.

Install packageView source

Write intent. Commit it. Replay into state.

Small, replayable documents you can verify, move, and rebuild anywhere.

Concord runtime

Deterministic
Writes
staged first
Commit
signed + linked
Payloads
optional encryption
Result
derived state

Concord stages commands, commits them into signed parent-linked history, supports encrypted payloads when needed, and rebuilds application state from replay instead of treating storage as authority.

Runtime Model

History is the source of truth. State is a projection.

Commands produce entries. Commits make them durable. Replay rebuilds application state from ordered history. If committed history changes, verification fails. If history can be replayed and verified, it can be trusted.

Command-first ergonomics

Work with domain commands like "todo.create-item" instead of hand-authoring low-level entries.

Explicit commit boundaries

Decide when staged work becomes durable. Commits bind ordered entries into a signed chain.

Optional encrypted payloads

Encrypt sensitive data before it enters history. Encryption stays explicit and portable.

Deterministic replay

Rebuild state from ordered history through replay plugins. No hidden mutation. No silent drift.

Portable History

A signed artifact you can inspect and validate

This artifact is exported from the live Concord runtime above. Change a commit. Break a parent link. Edit a payload. Verification fails immediately. This is the full portable application history.

proof.json
{
  "format": "concord-ledger",
  "version": "1",
  ...
}

Concord artifacts behave more like portable documents than traditional databases. Concord will not derive runtime state from corrupted or unverified history.

The Suite

Concord is part of a focused stack.

Concord is the runtime layer in a composable suite. Beneath it are tools for append-only history, portable proof, and encryption. Most applications only need Concord. The rest is there when you do.

Build at the runtime layer. Drop down when you need deeper control.

Seal

Seal

Produce portable cryptographic proofs for entries, commits, and exported artifacts.

Explore Seal
Armour

Armour

Encrypt payloads with explicit identity or passphrase contracts before they enter history.

Explore Armour
Ledger

Ledger

Stage, commit, replay, export, and verify append-only signed history.

Explore Ledger

Example

Build without giving storage authority

Create a Concord app, load or create its history, dispatch commands, commit authored changes, optionally encrypt payloads, and replay entries into isolated plugins. Query derived state, not raw history. Keep history for audit, verification, and rebuild.

  1. 1

    Create an app runtime

    Combine identity, storage, and replay plugins into a Concord app.

  2. 2

    Dispatch commands

    Express intent through domain commands. Concord stages structured entries.

  3. 3

    Commit authored history

    Group staged entries into a signed, parent-linked commit with meaningful metadata.

  4. 4

    Replay into state

    Replay plugins rebuild deterministic state or local projections.

  5. 5

    Verify integrity

    If committed history is altered, verification fails clearly and precisely.

History is signed. Payloads can be encrypted. State is derived. Storage is replaceable.

Developers

A small runtime for replayable, verifiable applications

Concord handles command routing, commit control, encryption boundaries, replay orchestration, and integrity enforcement without turning into a framework. History is durable truth. Projections are the query surface.

Command runtime

Explicit commit boundaries

Replay plugins

JavaScript

Create a Concord app

import { createConcordApp } from "@ternent/concord"
import { createTodoPlugin } from "@ternent/concord-plugin-todo"

const app = await createConcordApp({
  identity,
  storage,
  plugins: [createTodoPlugin()],
})

await app.load()

await app.command("todo.create-item", {
  id: crypto.randomUUID(),
  title: "Buy milk",
})

await app.commit({
  metadata: {
    message: "Create first todo",
  },
})

const verification = await app.verify()
const todoState = app.getReplayState("todo")

Dispatch commands. Commit intentionally. Replay signed history into state.

View source

Ready

Build apps from replayable, signed history.

Use Concord for command ergonomics, replay-driven state, and optional client-side encryption for sensitive data.

Install packageView source