Sirix is an evolutionary temporal NoSQL storage sytem at its heart, which efficiently stores the history of your data.
We store per revision and per page changes.

Sirix is especially well suited for flash drives as for instance SSDs due to its log structured copy-on-write nature.
We allow time-travel queries for your XML as well as JSON data
and store both in our binary on-disk structure or a lightweight in-memory structure.
It is released for free under The 3-Clause BSD License license. Have fun!

The following XQuery for JSON query basically opens a database/resource in a specific revision based
on a timestamp and searchs for a status, which didn't exist in the previous revision.


let $statuses := jn:open('mycol.jn','mydoc.jn', xs:dateTime('2019-04-13T16:24:27Z'))=>statuses
let $foundStatus := for $status in bit:array-values($statuses)
  let $dateTimeCreated := xs:dateTime($status=>created_at)
  where $dateTimeCreated > xs:dateTime("2018-02-01T00:00:00") and not(exists(jn:previous($status)))
  order by $dateTimeCreated
  return $status
return {"revision": sdb:revision($foundStatus), $foundStatus{text}}


Keep the full history of your data for time travel analysis, audits, to correct human or application errors...

We are taking care of keeping storage space to a minimum, while supporting the reconstruction of any revision in linear time.

Furthermore we allow time travel queries such that you're able to analyse the history of your data efficiently in order to predict the future or to do audits.

Not enough? What about correcting any human or application errors or to compare any revision of your XML- or JSON-documents efficiently?

Versioning done right

We are versioning data as well as index-structures on a per revision and per record/node level. As such versioning takes place at a fine-granular level. Furthermore through a novel versioning algorithm called sliding snapshot we are able to avoid write- and read-peaks.

Time travel queries

We allow sophisticated time travel queries, such that you are able to analyse the history of your data or to retrieve the differences efficiently.


You decide how your data looks like and which format fits best. We currently support both the import of XML as well as JSON data.

Powerful APIs


We built an asynchronous, RESTful API, which is non-blocking with Vert.x, Kotlin (especially coroutines are very powerful) and Keycloak for authorization.

XQuery / JSONiq

Several extensions to an XQuery-processor called Brackit are available. We for instance support navigation via novel temporal XPath axis not only in space but also in time. Furthermore, several additional precompiled functions are available to simplify the analysis of your temporal data. The API also provides a very convenient way to interact with Sirix. Think of it as an in-memory representation of a DOM.

Transactional cursor API

Our low-level, transactional, cursor based API is very powerful. We not only provide standard XPath axis and additionally temporal enhancements to navigate in time, but also several other axis as for instance a LevelOrder axis, a PostorderAxis, a DescendantAxis which can skip whole subtrees. Furthermore, we provide several filters and much more.


We provide a way to currently import several revisions of an XML-document with the help of a diffing-algorithm called Fast Matching Simple EditScript. With the help of this diff-algorithm we are able to import not the whole changed second, third and so on version of the document but only the encountered differences between any two versions.

Once we have stored several revisions in Sirix, either through the import diff-algorithm or simply through working with Sirix in the first place we are able to quickly compute diffs between any two revisions because of our stable node identifiers and optionally stored hashes (each time two hashes are equal, the whole subtree can be skipped).

Ready for using Sirix?

Give it a try and let us know what you think.