The Memory Model for Intelligence

The ecosystem

One branching model across Datalog, SQL, vectors, and search. Fork your entire world-state in O(1).

Collaborate without infrastructure

A Datahike database is a value - an immutable snapshot you can hold, share, and query anywhere. Readers connect directly to storage: no server to start, no API to negotiate, no ETL pipeline to maintain. If two teams share an S3 bucket, they can join their databases in a single Datalog expression.

; Two teams, two S3 buckets - no servers, no ETL pipeline
(def catalog   (d/connect {:store {:backend :s3 :bucket "team-a"}}))
(def inventory (d/connect {:store {:backend :s3 :bucket "team-b"}}))

; Join across databases in a single Datalog expression
(d/q '[:find ?name ?stock
       :in $cat $inv
       :where [$cat ?p :product/sku  ?sku]
              [$cat ?p :product/name ?name]
              [$inv ?i :stock/sku    ?sku]
              [$inv ?i :stock/count  ?stock]]
  @catalog @inventory)
; => #{["Widget A" 142] ["Widget B" 88]}

Datalog natively supports multi-database joins via :in. Both values are immutable snapshots - no locking, no coordination required. Learn more →

Show me

Examples in Java. Also: Clojure, JavaScript, Python, C/C++ (libdatahike), CLI (dthk), Babashka pod, HTTP REST.

import datahike.java.*;
import java.util.*;

var cfg = Database.file("/tmp/db")
    .keepHistory(true)
    .build();
Datahike.createDatabase(cfg);
var conn = Datahike.connect(cfg);

Datahike.transact(conn, List.of(
    Map.of(":user/name", "Ada",
           ":user/email", "ada@example.com")));

// Datalog query (EDN syntax)
var results = Datahike.q(
    "[:find ?e ?name :where [?e :user/name ?name]]",
    Datahike.deref(conn));
// => #{[1 "Ada"]}

// Query a past snapshot
var oldDb = Datahike.asOf(
    Datahike.deref(conn),
    Date.from(Instant.parse("2024-01-01T00:00:00Z")));
var history = Datahike.q(
    "[:find ?name :where [_ :user/name ?name]]",
    oldDb);

Full Datalog - joins, aggregates, pull expressions, rules.

JavaScript / Node.js (beta)

Install: npm install datahike@next

const d = require('datahike');
const crypto = require('crypto');

const config = {
  store: {
    backend: ':memory',
    id: crypto.randomUUID()
  },
  'schema-flexibility': ':read'  // Allow schemaless data (use kebab-case)
};

await d.createDatabase(config);
const conn = await d.connect(config);
await d.transact(conn, [{ name: 'Alice' }]);
const db = await d.db(conn);  // db() is async for async backends
const results = await d.q('[:find ?n :where [?e :name ?n]]', db);
console.log(results);
// => [['Alice']]

TypeScript definitions included. Same Datalog queries, Promise-based API. Try in your browser →

Notes

Occasional writing on databases, immutability, and semantic search.

In production

Used by developers and government agencies who need data they can trust.

Get started

Runs on the JVM. Distributed via Clojars.

<!-- Enable Clojars -->
<repository>
  <id>clojars</id>
  <url>https://repo.clojars.org/</url>
</repository>

<!-- Datahike dependency -->
<dependency>
  <groupId>org.replikativ</groupId>
  <artifactId>datahike</artifactId>
  <version>LATEST</version>
</dependency>

Clojure CLI, Leiningen, Gradle, and JavaScript: see the README on GitHub. Or try it in your browser →