Get Started with ReckonDB

Run the event store, then connect from any stack. Install ReckonDB itself below, and use the gateway, SDKs, and command-line tools to build, browse, and operate your streams.

Quick Start: ReckonDB can be running in under 5 minutes — and the reckon CLI installs with a single command.

Embedded Installation

For BEAM Applications • Hex Package

Perfect for Elixir and Erlang developers! Add ReckonDB directly to your application as a dependency and leverage the full power of the BEAM ecosystem with native performance and zero serialization overhead.

Installation Steps

1. Add the dependencies

ReckonDB is the event store; reckon_evoq is the adapter that wires the evoq CQRS/ES framework onto it. reckon_evoq pulls evoq (and reckon_gater) transitively, so you declare just two:

def deps do
  [
    {:reckon_db, "~> 2.3"},     # BEAM-native event store (Khepri/Ra, Raft)
    {:reckon_evoq, "~> 2.1"}    # evoq → ReckonDB adapter (brings evoq + reckon_gater)
  ]
end

Erlang projects use the same packages in rebar.config.

2. Fetch dependencies

mix deps.get

3. Configure a store and the adapter

Declare a ReckonDB store (it starts at boot) and point evoq at the reckon_evoq adapter for its event store, snapshots, and subscriptions:

# config/config.exs
config :reckon_db,
  stores: [my_store: [mode: :single]]   # data_dir defaults under the app's priv

config :evoq,
  store_id: :my_store,
  event_store_adapter: :reckon_evoq_adapter,
  snapshot_store_adapter: :reckon_evoq_adapter,
  subscription_adapter: :reckon_evoq_adapter

Now model your domain with evoq — commands, events, aggregates and projections — and they persist to ReckonDB through the adapter. See the evoq guides for your first slice.

Benefits

  • Raft consensus (Khepri/Ra) — replicated, linearizable event streams with no external coordinator.
  • Automatic clustering — nodes self-discover via UDP multicast or Kubernetes DNS and join the Raft group, from a Nerves device to a datacenter.
  • Tamper-evident storage — integrity-enabled stores hash-chain events (SHA-256 / Ed25519 crypto NIF); reads against tampered storage fail loudly.
  • Optimistic concurrency — versioned appends with expected-version checks for safe concurrent writers.
  • Persistent subscriptions — by stream, event type, pattern or payload, with server-side checkpoints.
  • Snapshots & projections — aggregate snapshots and projection checkpoints, managed by the adapter.

Standalone Installation

Language Agnostic • Docker Container

Universal solution for any tech stack! Run ReckonDB as a standalone service and connect from any language. Perfect for microservices, polyglot architectures, and production deployments with full clustering support.

Quick Start

Run reckon-gateway — the gRPC frontend to ReckonDB — and connect from any language. ReckonDB speaks gRPC on port 50051 (not the PostgreSQL wire protocol).

1. Run the gateway

docker run -p 50051:50051 ghcr.io/reckon-db-org/reckon-gateway:latest

(Or build it from source — see the gateway repo.)

2. Connect over gRPC

Use the reckon CLI, the Go SDK, or a client generated from the proto for your language:

# install the CLI, then:
reckon -e localhost:50051 stores list

3. Point at your ReckonDB cluster(s)

The gateway routes each request to the ReckonDB cluster that owns the store. Nodes self-discover (UDP multicast or Kubernetes DNS) and replicate over Raft — see the gateway repo for catalogue/cluster configuration.

Benefits

  • Language-agnostic — one gRPC contract; a native Go SDK plus generated clients for any language via the proto.
  • Single endpoint, many clusters — the gateway fronts multiple distributed ReckonDB clusters and routes by store.
  • Raft-replicated storage — Khepri/Ra consensus with automatic node discovery; from Nerves devices to Kubernetes.
  • Tamper-evident — integrity-enabled stores hash-chain events (SHA-256 / Ed25519); reads against tampered storage fail loudly.
  • Persistent subscriptions & snapshots — server-side checkpoints, by stream, event type, pattern or payload.

Connect & Build

The gateway, SDKs, and tools for working with your event store from any stack — over a single gRPC contract.

reckon-gateway

gRPC ingress • Erlang/OTP

Exposes ReckonDB to clients in any language and routes across distributed clusters. Deploy it, then point clients at its endpoint.

docker run -p 50051:50051 ghcr.io/reckon-db-org/reckon-gateway:latest
Deploy the gateway →

reckon CLI

Shell & scripting • no Go needed

Browse stores, read and tail streams, inspect subscriptions and snapshots — JSON in, JSON out — straight from your terminal.

curl -fsSL https://codeberg.org/reckon-db-org/reckon-go/raw/branch/main/scripts/install.sh | sh
reckon CLI →

reckon-go (SDK)

Idiomatic Go client

Typed clients for all gateway services with channel-based streaming. The foundation the CLI and TUI are built on.

go get codeberg.org/reckon-db-org/reckon-go
Go SDK →

gRPC API

Polyglot wire contract

The canonical protobuf contract — nine gRPC services. Generate a native client for any language with buf or protoc.

buf generate https://codeberg.org/reckon-db-org/reckon-proto.git
API contract →

lazyreckon

Terminal UI • lazygit-style

A keyboard-driven TUI for your event store: drill from stores to streams to events, watch subscriptions, peek at snapshots.

go install codeberg.org/reckon-db-org/reckon-lazy/cmd/lazyreckon@latest
lazyreckon →

Need the full picture?

How the gateway, SDKs and the event store fit together — concepts, API reference and examples.

Browse the API reference →

What's Next?

Try the Demos

See ReckonDB in action with our interactive demo applications showcasing real-world use cases.

Explore Demos →

Read the Docs

Dive deep into ReckonDB's architecture, APIs, and advanced features with our comprehensive documentation.

View Documentation →

Join the Club!

Connect with other ReckonDB users, get help, and stay updated on the latest developments.

Join Community →

Ready to Build Something Amazing?

ReckonDB makes event sourcing and CQRS accessible to everyone. Start building today!