Open-Source Databases · replikativ

datahike

Datahike is a Datalog database engine with Datomic-compatible APIs that treats data as immutable, versioned snapshots. It supports time-travel queries, multiple storage backends (file, LMDB, S3, Redis, IndexedDB), and cross-platform deployment (JVM, Node.js, browser).

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/replikativ/datahike

1.8k

GitHub stars

113

Forks

Clojure

Primary language

EPL-1.0

License (Requires review (not clearly OSI))

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	replikativ/datahike
Owner	replikativ
Primary language	Clojure
License	EPL-1.0 — Requires review (not clearly OSI)
Stars	1.8k
Forks	113
Open issues	80
Latest release	0.8.1719 (2026-07-08)
Last updated	2026-07-08
Source	https://github.com/replikativ/datahike

What datahike is

Built on persistent data structures and structural sharing, Datahike provides a query engine for complex relational data without explicit joins. It offers distributed read scaling via persistent indices, real-time WebSocket sync via Kabel, and append-only transaction semantics enabling full audit trails and GDPR-compliant data excision.

Quickstart

Get the datahike source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/replikativ/datahike.git2cd datahike3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Knowledge graphs and complex relationship queries

Applications requiring transitive relations, recursive rules, and multi-entity pattern matching (e.g., organizational hierarchies, supply chains, taxonomy systems). Datalog's declarative nature simplifies graph traversal versus SQL joins.

Audit-critical and regulatory compliance systems

Immutable append-only semantics with time-travel queries enable complete data lineage and historical reconstruction. GDPR data purging support allows targeted fact excision while maintaining audit integrity.

Offline-capable, real-time collaborative applications

Browser/Node.js IndexedDB with Kabel WebSocket sync and git-like branching semantics enable offline-first architectures with eventual consistency and distributed query execution on local indices.

Implementation considerations

Schema flexibility is configurable (strict by default, tunable via `:schema-flexibility` option). Plan for schema versioning if deploying across teams.
Storage backend choice (file vs. LMDB vs. cloud) affects operational complexity; file-based suitable for dev/small deployments, LMDB/S3 for production scaling.
Time-travel and historical data accumulation grow storage over time; plan retention and purging policies early, especially under GDPR.
Query performance depends on index configuration and relationship cardinality. Requires benchmarking for billion-datom scales mentioned in docs.
Cross-platform bindings (JavaScript, Java) are beta; production JVM deployments are better tested than browser/Node.js variants.

When to avoid it — and what to weigh

Transactional consistency across distributed nodes is critical — Datahike's distributed design prioritizes read scaling and offline capability over strong transactional guarantees. Multi-node write consistency is not clearly stated in provided data.
Team has no Clojure/functional programming expertise — Primary language is Clojure with beta bindings to Java, JavaScript, and Python. Query syntax is Datalog (not SQL). Adoption requires retraining or hiring in a niche skill set.
You need enterprise SLA and vendor support — OSS project with community Slack; no commercial support structure documented. Production deployment requires internal DevOps capability and community engagement for issue resolution.
Simple CRUD operations on relational schemas — Datalog's power comes from complex querying and relationships. Overhead of immutable snapshots and historical tracking is unnecessary for straightforward transactional workloads; SQL databases are simpler.

License & commercial use

Licensed under Eclipse Public License 1.0 (EPL-1.0), a weak copyleft OSI-approved license. Derivative works must be released under EPL-1.0 or compatible license; linking for proprietary use is permitted with careful analysis of modification boundaries.

EPL-1.0 permits commercial use without royalty. However, if your product modifies Datahike internals (not mere data storage or API calls), those modifications must be open-sourced under EPL-1.0 or a compatible license. Consult legal counsel on linking and modification scope before production deployment. No commercial support entity documented.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Strong
License clarity	Clear
Deployment complexity	Moderate
DEV.co fit	Good
Assessment confidence	High

Security considerations

EPL-1.0 licensing; no explicit security audit or CVE history provided. Append-only transaction semantics support audit trails and data provenance. GDPR purging feature enables targeted data excision but does not guarantee forensic deletion (backend-dependent). Kabel WebSocket sync for browser clients requires TLS/authentication layer (external responsibility). IndexedDB browser storage is same-origin only but not encrypted at rest. Threat modeling and penetration testing results unknown.

Alternatives to consider

Datomic (commercial)

Datahike explicitly aims for Datomic API compatibility and immutable semantics. Datomic offers stronger vendor support and cloud hosting but is commercial and proprietary; Datahike is OSS and self-hosted.

RDF/SPARQL triplestores (e.g., Apache Jena, Virtuoso)

Alternative for knowledge graphs; both support pattern-matching queries over relationships. SPARQL is W3C standard and broader ecosystem, but Datahike integrates with Clojure tooling and git-like versioning.

PostgreSQL with JSON/JSONB or standard SQL

Mature, widely understood, no schema versioning overhead. SQL joins accumulate complexity for graph workloads; Datalog avoids this but requires learning curve and Clojure expertise.

Software development agency

Build on datahike with DEV.co software developers

Datahike's Datalog engine and git-like versioning simplify auditable, knowledge-graph applications. Explore the documentation, review the Beleg invoice example, and prototype in your environment.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

datascript olake datalens

Related on DEV.co

Explore the category and the services that help you build with it.

Open-Source Databases Custom Software Development API Development Talk to DEV.co

datahike FAQ

Can I use Datahike without learning Clojure?

Partially. JavaScript API (beta) and Java API (beta) exist, but query syntax is Datalog (not SQL) and documentation is Clojure-centric. Beta status and limited ecosystem tooling outside Clojure increase friction.

Does Datahike replace PostgreSQL or MySQL?

For different use cases. Datahike excels at versioned, relational data with time-travel queries and offline sync. PostgreSQL is better for transactional CRUD, strong consistency, and broad integrations. Both can coexist in a system.

What happens to my data if I want to migrate away?

Export via queries to standard formats (Clojure data structures, JSON); no vendor lock-in by design. Datoms are immutable facts, enabling standard serialization. Migration tooling not documented.

Is Datahike suitable for production?

Yes, with caveats. README cites billion-datom deployment in government services. JVM backend is stable; JavaScript/CLI are beta. Requires internal DevOps capability and community support (no commercial SLA).

Software developers & web developers for hire

Adopting datahike is usually one piece of a larger software development effort. As a software development agency, DEV.co provides software development services and web development expertise — pairing senior software developers and web developers with your team to design, build, and operate open-source databases software in production.

Ready to Build Complex Relational Systems?

Datahike's Datalog engine and git-like versioning simplify auditable, knowledge-graph applications. Explore the documentation, review the Beleg invoice example, and prototype in your environment.

Talk to DEV.co Schedule a Consultation