A knowledge graph in plain SQLite.

Built around how SQLite runs queries.

Using SQLite as a triple store is not new. oxilite adds a design shaped by SQLite's executor and by the cost of a remote SQLite, where every round-trip and every index row is billed.

Get started.

Pick your platform. The API mirrors Oxigraph, so existing code usually needs only a changed import.

# Cargo.toml: oxilite = "0.9"   (features: rusqlite (default), dylib, turso, d1, cypher, datalog, synalog, reasonable)
use oxilite::store::Store;             // was: use oxigraph::store::Store;
use oxilite::io::RdfFormat;

let store = Store::open("data.sqlite")?;   // Store::open_turso(…) for vector search
store.load_from_reader(RdfFormat::Turtle, TURTLE.as_bytes())?;
store.query("SELECT ?s WHERE { ?s a <http://schema.org/Person> }")?;
store.update("INSERT DATA { <http://ex/a> <http://ex/p> 42 }")?;
store.optimize()?;                     // refresh planner statistics

// npm install @oxilite/node
import { Store } from "@oxilite/node";

const store = new Store("data.sqlite");
store.load(`@prefix ex: <http://ex/> . ex:a ex:knows ex:b .`, { format: "text/turtle" });

for (const row of store.query("SELECT ?x WHERE { ?x ?p ?o }")) {
  console.log(row.get("x")?.value);
}

# pip install oxilite
from oxilite import Store, RdfFormat     # was: from pyoxigraph import …

store = Store("data.sqlite")
store.load("@prefix ex: <http://ex/> . ex:a ex:knows ex:b .", RdfFormat.TURTLE)

for solution in store.query("SELECT ?x WHERE { ?x ?p ?o }"):
    print(solution["x"].value)

// Maven: com.oxilitedb:oxilite-jvm:0.9.1
import com.oxilitedb.oxilite.Store;
import com.oxilitedb.oxilite.model.*;

try (Store store = new Store("data.sqlite")) {
  store.load("@prefix ex: <http://ex/> . ex:a ex:knows ex:b .", "text/turtle");

  for (var row : store.query("SELECT ?x WHERE { ?x ?p ?o }").get("rows")) {
    System.out.println(row.get(0).get("value").asText());
  }
}

cargo install oxilite-cli
oxilite load    -l data.sqlite -f dump.nt            # bulk load, then refresh statistics
oxilite query   -l data.sqlite -q 'SELECT * WHERE { ?s ?p ?o } LIMIT 5'
oxilite explain -l data.sqlite -q '…'              # the SQL and the join order
oxilite serve   -l data.sqlite -b 127.0.0.1:7879     # /query, /update, /store

One jar for Java, Kotlin, Scala and Clojure.

com.oxilitedb:oxilite-jvm on Maven Central wraps the same store Node.js and Python already have, over JNI. RDF terms and quads are typed classes, not raw JSON, and the native library for every platform ships inside one jar, so any JVM language reaches it through ordinary interop.

import com.oxilitedb.oxilite.Store;
import com.oxilitedb.oxilite.model.*;

try (Store store = new Store("team.sqlite", null, "{\"versioning\": \"log\"}")) {
  store.setCommitInfo("{\"author\": \"ada\", \"message\": \"import\"}");
  store.load(Files.readString(Path.of("team.ttl")), "text/turtle");

  store.query("SELECT ?p WHERE { ?p a ex:Person }", "{\"reasoning\": \"rdfs\"}");
  store.cypher("MATCH (a)-[:knows]->(b) RETURN b.name AS friend", null, "{\"base\": \"http://ex/\"}");
  store.datalog("reach(?x, ?z) :- ex:knows(?x, ?y), reach(?y, ?z). …");
  store.query("SELECT * WHERE { ?s ?p ?o }", "{\"asOf\": \"HEAD~1\"}");   // the store one commit ago
}

How to use oxilite on the JVM → · Maven Central →

Reasoning and validation included.

The pieces a knowledge graph needs, reused from the Rust RDF ecosystem.

Rules that recurse.

SPARQL stops at property paths: one predicate, a fixed pattern, no way to filter part-way through. Datalog gives you recursion with a body — joins, constraints, negation — and it compiles to a single WITH RECURSIVE statement, so it is still one round trip on D1.

// Cargo.toml: oxilite = { version = "0.2", features = ["datalog"] }
store.datalog(r#"
  @prefix ex: <http://example.org/> .

  ancestor(?x, ?y) :- ex:parent(?x, ?y).
  ancestor(?x, ?z) :- ex:parent(?x, ?y), ancestor(?y, ?z).   // recursion

  adult(?x, ?y) :- ancestor(?x, ?y), ex:age(?y, ?a), ?a >= 18.
  orphan(?x)    :- ex:Person(?x), not ancestor(_, ?x).       // stratified negation
  lines(?x, COUNT(?y)) :- ancestor(?x, ?y).                  // aggregation

  ?- adult(?x, ?y).
"#)?;

An IRI with two arguments is a predicate, so ex:parent(?x, ?y) is the triple pattern ?x ex:parent ?y; with one it is a class, so ex:Person(?x) is ?x rdf:type ex:Person. Constraints are the SPARQL expression language, pushed into the join rather than applied to its rows.

SQLite’s restrictions are Datalog’s classical safety conditions, so the compiler reports them as rule diagnostics instead of working around them. explain_datalog() shows the strata, the strategy picked for each recursive component, and the SQL.

Available from Rust, from the CLI (oxilite datalog -l db.sqlite -f rules.dl), from Python (store.datalog(program)), and from JavaScript — @oxilite/node and @oxilite/d1 both return RDF/JS terms. In the WebAssembly core it is an opt-in feature (~0.2 MB), so a Worker that does not use rules does not carry it.

Or write rules in Synalog

Synalog, the Datalog-family language for AI agents — named arguments, expressions, head aggregation, ordered and pageable results — runs over the same store as a second rule dialect. Triples read as tables: triples(subject, predicate, object, kind, datatype, lang, graph), plus the ones a program declares with # @table parent <http://example.org/parent>, with terms decoded to numbers and strings. Graph scope, inferences and time travel (asOf) work as they do for Datalog.

# @table parent <http://example.org/parent>
@Recursive(Ancestor, 10);
Ancestor(x:, y:) distinct :- parent(subject: x, object: y);
Ancestor(x:, y:) distinct :- Ancestor(x:, y: m), parent(subject: m, object: y);

store.synalog(program, "Ancestor") from Rust, Python, Node.js and D1, or oxilite synalog Ancestor -f rules.l. Read how it differs from Datalog →