XTDB Blog

Datomic is an event-sourced db, and it makes it hard to introduce retroactive corrections to the data when your program's semantic already rely on using datomic's time travelling abilities: at one point you'll need to to distinguish between event time and recording time as explained in this excellent blog post: https://vvvvalvalval.github.io/posts/2018-11-12-datomic-event-sourcing… This is why I' rather use XTDB [1], a database similar to datomic in spirit, but with bitemporality baked in. [1] https://www.xtdb.com

Hi, I am running a webinar on the concept of bitemporal data management next week, as in https://en.wikipedia.org/wiki/Bitemporal_modeling - please sign up up here if you are at all interested: https://attendee.gotowebinar.com/register/2960607012900067930?source=h… I work on https://xtdb.com which is a novel database system that attempts to make bitemporal modeling more trivial (all data is bitemporal automatically!) - but this webinar is more generally about the concept, rather than our own work. I've spent the last 4 years getting to grips with bitemporality in all its shapes & guises, and am more convinced than ever that this fundamental concept of cleanly separating the-timeline-of-the-system from the-timeline-of-the-data deserves wider attention. There will be a Q&A discussion at the end of the webinar where it would be great to share stories and tips live, if you have any! And in the meantime I would be very glad to swap thoughts in the comments below. Thanks.

While the author mentions that he just doesn't have the time to look at all the databases, none of the reviews of the last few years mention immutable and/or bi-temporal databases. Which looks more like a blind spot to me honestly. This category of databases is just fantastic for industries like fintech. Two candidates are sticking out. https://xtdb.com/blog/launching-xtdb-v2 (2025) https://blog.datomic.com/2023/04/datomic-is-free.html (2023)

I was asking the same question today after investigating XTDB¹ (a Clojure centric bitemporal DB) and went looking for a batteries included WebAssembly framework like Blazor² 1. https://xtdb.com/ 2. https://dotnet.microsoft.com/en-us/apps/aspnet/web-apps/blazor

A lot of these same problems were solved in a similar way with Datomic and xtdb. https://www.datomic.com/ https://xtdb.com/

The - now free - Datomic (https://www.datomic.com) or the open source XTDB (https://www.xtdb.com) can provide instant access to your data at any point in time. Even to different points in time within a single query, without the concept of a "DB restore" operation. So if your main use-case of restoring a DB from the past is to run analytical queries on it, then you should probably consider these solutions instead. These systems rely on other databases to store their data, so they inherit the backup capabilities of those databases. Would be interesting to consider, if they could benefit from using SQLite as a backend instead of H2DB/DynamoDB/Postgres or RocksDB/LMDB/Xodus/JDBC.

There are also similar datalog immutable databases with fully open source codebases out there too like https://www.xtdb.com/ or https://datahike.io/

There's a bitemporal Datomic-like database from JUXT that does exactly that, I believe https://www.xtdb.com

I guess it's impossible to know what you've seen before and dismissed as not having sufficient features/attributes/popularity. Or what types of project would cause you to dig in but here are a few innovative projects using clojure that represent a fairly diverse set of interests. - https://github.com/overtone/overtone - https://xtdb.com/ - https://github.com/kennytilton/matrix - https://github.com/metasoarous/oz

> I dream of a SQLite-like embeddable database engine based on Datomic’s data model and queryable with Datalog. You can have this today by running XTDB[1] on top of SQLite via JDBC. > Written in something like C, Rust, or Zig. And then compiling your application into native executables with GraalVM Native Image[2]. [1] https://xtdb.com/ [2] https://www.graalvm.org/native-image/

XTDB is a general-purpose bitemporal database with graph query capabilities: https://xtdb.com/

There is a similar open-source database called XTDB: https://xtdb.com/ I still haven’t found the activation energy, though.

If anyone is interested, I am attempting to revive an open source clone of Datomic called EVA. As is the original codebase works fine, its just unmaintained. My hope is to clean up the code, make an HTTP layer for a remote peer, and make a Rust embedded peer so that this sort of Database can finally escape the JVM. https://github.com/bowbahdoe/eva If you want to use something open source today that has the same query language but a different data model, https://xtdb.com/ is high quality.

XTDB (https://xtdb.com) while is not directly for Postgres is at least not reliant on devs knowing Clojure. It's very close to Datomic in terms of approach. They expose SQL, Java, HTTP APIs.

I submit that Event Sourcing (or at least something very close to it) can be easy, once you've removed some technology locks. I've seen it happen with Datomic (https://vvvvalvalval.github.io/posts/2018-11-12-datomic-event-sourcing… but it can probably happen similarly with other tech, such as XTDB (https://xtdb.com/).

https://xtdb.com maybe?

What about https://xtdb.com/

Does somebody have experience with XTDB https://xtdb.com/index.html ? We would like to use it in our Clojure application perhaps with PostgreSQL as the backend (JDBC) to make it easier to implement a history feature. Looking forward, instead of backward, it would be great for databases to have some kind of live-patch/ live-update feature so that one does not need any downtime at all if some rules are obeyed (with an automatic check, if that is the case). The same is for operating systems, where we have parts of the technology and even some limited deployment, but nothing of it is the default as far as I know. This situation makes it quite a bit harder to develop and maintain systems without introducing extreme complexity. It does not look like we will have less bugs/ less patches any time soon so we should make updating as easy as possible to drastically reduce the need for a maintenance window without resorting to building clusters for everything.

It is! And also it has inspired a few other clojure datalog databases, so there is much more choice: * https://github.com/datalevin/datalevin * https://github.com/replikativ/datahike * https://github.com/threatgrid/asami There is also xtdb, but it abandoned datalog and is going in another (albeit interesting direction) https://xtdb.com/ here is a comparison website, but it is somewhat out of date: https://clojurelog.github.io/

I think JUXT are primarily a consultancy? But they are also offering paid support plans for xtdb: https://www.xtdb.com/support/production

From the 2.x homepage it looks like they intend to offer a usage-based XTDB cloud service: https://www.xtdb.com/v2

Can’t say what people are using but keen to hear from others. I am looking into this atm, no implementation yet, and some of the things I am reading about are (I’ll add dolt to this list) Xtdb: https://xtdb.com/ Terminus: https://github.com/terminusdb/terminusdb Nessie: https://projectnessie.org/ Dvc : https://dvc.org Liquid base: https://liquibase.org/ Datasette: https://datasette.io/ Still framing in my mind how schema evolution, x-temporal and e.g. scd in data modelling, version control etc. tie in together in an approach.

For the people at home that might think "Where have I seen this before?": XTDB is a rename of Crux. You can see the announcement about the name change here: https://xtdb.com/blog/crux-to-xtdb-rename.html

Have you heard of XTDB / Bitemporality? The basic idea is to make time 2-dimensional, where each record has both a System Time range and a Valid Time range. Designed as a write-only db with full auditability for compliance purposes. With 2D time you can ask complex questions about what you knew when, with simpler questions automatically extended into a question about the current time. Like: "What is the price?" -> "What is the price today, as of today?" "What was the price in 2022" -> "What was the price in 2022, as of today?" "What was the price in 2022, as of 2023?" You probably don't want to just switch to XTDB, but if you pursue this idea I think you should look into 2D time as I think it is schematically the correct conceptualization for this problem. Docs: https://docs.xtdb.com/concepts/key-concepts.html#temporal-columns--bit… | 2025 Blog: https://xtdb.com/blog/diy-bitemporality-challenge | Visualization tool: https://docs.xtdb.com/concepts/key-concepts.html#temporal-columns--bit…