Skip to content
Vaylix logo Vaylix logo Vaylix Docs
Vaylix

A secure, consensus-backed key-value database for operational state.

Vaylix is a key-value store built for operational state that must survive crashes. It fsyncs every acknowledged write and, in HA mode, commits writes to a quorum before returning success.

Current line: server v0.9.0, TypeScript SDK 0.4.0, Go SDK 0.1.0. Pre-1.0 means the storage format and compatibility policy are documented explicitly instead of implied.

  • Raft-style quorum replication
  • Encrypted WAL and snapshots
  • Auth and RBAC enabled by default
  • Structured binary protocol (VTP2)
  • Deterministic error codes
  • Production-oriented runtime

Minimal example

Terminal window
docker run --rm \
  -p 9173:9173 \
  -v vaylix-data:/var/lib/vaylix \
  -e VAYLIX_USER=vaylix \
  -e VAYLIX_PASSWORD=vaylix \
  ghcr.io/vaylix/vaylix:0.9.0

What Vaylix is

Vaylix is a durable key-value database for control-plane and operational state. It keeps transport, server policy, and storage separated so write durability, failure handling, and access control stay explicit instead of implicit.

Who it is for

  • Configuration and feature flag storage
  • Distributed coordination metadata
  • Rate limiting counters with TTL
  • Session coordination state
  • Internal platform state that must be consistent across nodes

What it is not for

  • Caching: use Redis or Valkey
  • Application data storage: use Postgres
  • Kubernetes cluster coordination: use etcd
  • Pub/sub messaging: use Redis, Valkey, or NATS

What it guarantees

  • Every acknowledged write has been fsynced to the WAL.
  • On a replicated cluster, every acknowledged write has been committed to a quorum.
  • Reads on the same connection are consistent with the last committed write.
  • The audit log is hash-chained and tamper-evident at startup.

What it does not guarantee

  • No MVCC.
  • No distributed transactions.
  • No claim beyond serialized leader execution, WAL durability, and quorum-backed acknowledgement.
  • No linearizable follower reads.

Architecture overview

client -> transport -> server -> engine
replication -> WAL -> snapshot
  • Transport owns framing, negotiation, compression, and request decoding.
  • The server owns auth, RBAC, maintenance mode, replication policy, and request routing.
  • The engine owns durable state, WAL replay, snapshots, and logical backup data.

Getting started in five minutes

Start one node with Docker, connect with an SDK, and write a durable key. Follow the full guide for local clustering, TLS, and non-default credentials.

Run the server

Terminal window
docker run --rm \
  -p 9173:9173 \
  -v vaylix-data:/var/lib/vaylix \
  -e VAYLIX_USER=vaylix \
  -e VAYLIX_PASSWORD=vaylix \
  ghcr.io/vaylix/vaylix:0.9.0

Connect with TypeScript 

import { createClient } from '@vaylix/client';


const client = createClient({
  url: 'vaylix://vaylix:vaylix@127.0.0.1:9173',
});


await client.connect();


try {
  await client.set('config:feature-x', 'enabled');
  const value = await client.get('config:feature-x');
  const ttlApplied = await client.expire('config:feature-x', 60);
  const casOk = await client.set('config:feature-x', 'disabled', { ifVersion: 1n });


  console.log({ value, ttlApplied, casOk });
} finally {
  await client.close();
}

Connect with Go 

package main


import (
  "context"
  "log"


  vaylix "github.com/vaylix/vaylix-go"
)


func main() {
  ctx := context.Background()


  client, err := vaylix.Connect(ctx, vaylix.Options{
    URL: "vaylix://vaylix:vaylix@127.0.0.1:9173",
  })
  if err != nil {
    log.Fatal(err)
  }
  defer client.Close()


  if _, err := client.Set(ctx, "config:feature-x", "enabled", nil); err != nil {
    log.Fatal(err)
  }
}

Use the CLI

vaylix-client opens an interactive REPL.

Terminal window
$ vaylix-client --url 'vaylix://vaylix:vaylix@127.0.0.1:9173'
vaylix> SET config:env production
OK
vaylix> GET config:env
production
vaylix> SET config:env staging IF VERSION 1
true
vaylix> GET config:env
staging
vaylix> TTL config:env
-1
vaylix> EXIT
$
Open the full getting started guide Read the comparison guide