OxiRS 0.2.4 Released — A Hardening Pass for the JVM-Free Knowledge Graph

The triple store that never spins up a JVM just got steadier on its feet.

Today we released OxiRS 0.2.4 — a hardening and dependency-refresh pass over the Rust-native platform for Semantic Web, SPARQL 1.2, GraphQL, and AI-augmented reasoning.

No JVM. No JAVA_HOME. No 400 MB of jars to babysit. OxiRS is the Rust-first answer to Apache Jena + Fuseki (and to Juniper on the GraphQL side): the same dataset speaks both SPARQL 1.2 and GraphQL, every crate works stand-alone, and the whole thing compiles to a single static binary you can drop on a box — keeping the footprint under 50 MB while matching the incumbents feature-for-feature.

Why 0.2.4 matters

Anyone who has run Jena/Fuseki in production knows the tax: a JVM to tune, GC pauses to chase, a heap to size, and a deployment story that starts with “first, install a JDK.” OxiRS replaces all of that with a native binary — but a native binary still has to earn trust. 0.2.4 is the release where we spent the effort making the platform boringly dependable rather than adding new surface area.

This release lands on top of the big 0.2.x feature push — 26 functional modules across 16 development rounds, advanced SPARQL algebra (EXISTS/MINUS evaluators, subquery builder, SERVICE clause, LATERAL join), a six-index store, vector search, and DID/Verifiable-Credential support — and tightens the bolts:

40,786 tests passing, 100% pass rate, zero compilation warnings across all 26 crates.
Production unwrap() audit complete: every one of the 18,554 unwrap() calls in the tree was confirmed to live inside test blocks — zero production violations.
3.8x faster optimizer with adaptive complexity detection carries over from the 0.2.x line.
Security advisories reviewed: RUSTSEC-2026-0002 (lru reached via tantivy) was triaged and documented as not exploitable in OxiRS’s usage.

Technical Deep Dive: what changed under the hood

1. Pure-Rust-by-default GPU gating. OxiRS’s RDF-star acceleration in oxirs-star previously pulled scirs2-core::gpu imports unconditionally. In 0.2.4 those imports moved behind a gpu Cargo feature, and GpuAccelerator::initialize_context grew a CPU-only fallback for the default build. The result: a stock cargo build is 100% Pure Rust with no GPU toolchain assumptions, and GPU paths are strictly opt-in. This is the COOLJAPAN Pure-Rust policy in action — C/C++/Fortran (and CUDA) dependencies are feature-gated, never default.

2. A CLI that stops fighting itself. The oxirs command had several clap short-flag collisions where the same letter was bound twice. 0.2.4 disambiguates them across cli_actions.rs, performance.rs, rebac.rs, and lib.rs — -i → -I, -c → -C, -v → -V, -q → -Q, with -n made explicit. Small change, big quality-of-life win for anyone scripting against the CLI.

3. A coherent dependency baseline. The whole 26-crate workspace was bumped to 0.2.4 in lockstep, and the foundations underneath were refreshed: SciRS2 0.3.3 → 0.4.1 (all 12 scirs2-* sub-crates), the OxiARC compression family (oxiarc-archive, oxiarc-zstd, oxiarc-lz4) 0.2.4 → 0.2.6, plus tokio-tungstenite 0.29, uuid 1.23, redis 1.1, kube 3.1, toml 1.1, and proptest 1.11. digest and sha2 were pinned to 0.10 for cross-crate compatibility.

4. The layered crate stack. OxiRS is modular by design: oxirs-core (zero-dependency RDF + SPARQL), oxirs-arq (the query engine), oxirs-shacl (validation), oxirs-vec (vector search), oxirs-tdb (TDB2-compatible storage), oxirs-fuseki/oxirs-gql (the HTTP servers), and the AI tier — oxirs-embed, oxirs-chat, oxirs-graphrag. You take only what you need.

Getting Started

Install the CLI:

cargo install oxirs

Spin up a knowledge graph in four lines:

# Initialize a new knowledge graph
oxirs init mykg

# Import RDF data (auto-persisted to mykg/data.nq)
oxirs import mykg data.ttl --format turtle

# Query it (data is loaded from disk automatically)
oxirs query mykg "SELECT * WHERE { ?s ?p ?o } LIMIT 10"

# Serve a Fuseki-style endpoint
oxirs serve mykg/oxirs.toml --port 3030

Then open http://localhost:3030 for the admin UI, or http://localhost:3030/graphql for GraphiQL.

Prefer to embed the engine? Pull in the library crate directly:

cargo add oxirs-core

What’s New in 0.2.4

Pure-Rust default builds — GPU acceleration in oxirs-star is now behind the gpu feature with a CPU-only fallback for GpuAccelerator::initialize_context.
CLI flag fixes — duplicate clap short flags resolved (-i/-c/-v/-q/-n) across four modules.
Dependency refresh — SciRS2 0.4.1, OxiARC compression 0.2.6, plus updated tokio-tungstenite, uuid, redis, kube, toml, and proptest.
Compatibility pins — digest and sha2 held at 0.10.
Workspace lockstep — all 26 crates bumped to 0.2.4, 40,786 tests green with zero warnings.

Tips

Keep it Pure Rust. The default feature set needs no GPU toolchain. Only add --features gpu to oxirs-star when you actually have hardware to target — otherwise the CPU fallback path is what you want.
Re-check your CLI scripts. If you scripted against the old short flags, note the renames: capital -I, -C, -V, -Q. Long flags are unchanged and are the safest thing to script against.
Persistence is automatic. oxirs import writes straight to mykg/data.nq, and queries auto-load from disk — there is no separate save/load step to remember.
Adopt incrementally. Start with oxirs-core for parsing and SPARQL, then opt into oxirs-vec, oxirs-shacl, or the AI crates only as you need them. Each is independently usable.
Mind the advisory note. RUSTSEC-2026-0002 surfaces via tantivy’s lru; it is documented as not exploitable in OxiRS, but it is worth knowing where it comes from if your scanner flags it.

This is the foundation

OxiRS is part of the COOLJAPAN ecosystem of Pure-Rust infrastructure. It builds directly on SciRS2 for its scientific and graph-analytics core, and on the OxiARC family (oxiarc-archive, oxiarc-zstd, oxiarc-lz4) for all compression — no zip, zstd, or flate2 C dependencies. Sibling projects like OxiZ (SMT), OxiFFT, and OxiRAG round out a stack where the entire path from bytes on disk to a SPARQL answer is auditable Rust.

Repository: https://github.com/cool-japan/oxirs

Star the repo if a JVM-free, single-binary knowledge graph sounds like the future you want to build on. Pure Rust Semantic Web is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ March 29, 2026