◉ COOLJAPAN
← All posts
June 7, 2026 • 8 min read

OxiRS 0.3.1 Released — SHACL Advanced Features, RDF-star in the Query Engine, and a C-Free Crypto Build

OxiRS 0.3.1 completes SHACL Advanced Features (recursive + qualified value shapes + a rule-based reasoning engine), pushes RDF-star quoted triples through the whole query pipeline, adds GraphSAGE inductive embeddings, and finishes the Pure-Rust migration — the default build now links zero ring / aws-lc-sys C crypto.

release oxirs rdf sparql shacl rdf-star knowledge-graph pure-rust fips

SHACL Advanced Features are done, quoted triples now flow through the whole engine, and the default build links not a single line of C crypto.

Today we released OxiRS 0.3.1 — a hardening release for the Rust-native Semantic Web / SPARQL 1.2 / GraphQL platform that completes SHACL Advanced Features, brings RDF-star into the query executor itself, and finishes the COOLJAPAN Pure-Rust migration end to end.

No JVM. No ring. No aws-lc-sys quietly compiling C and assembly under your “Rust” crypto. OxiRS stays the Rust-first replacement for Apache Jena + Fuseki — one dataset speaking both SPARQL 1.2 and GraphQL, every crate stand-alone, compiled to a single static binary. With 0.3.1, cargo tree -i ring and cargo tree -i aws-lc-sys both come back empty for the default feature set. The whole crypto path is auditable Rust.

Why OxiRS 0.3.1 is a game changer

Two long-running threads land in this release, and a third quietly disappears.

SHACL gets its advanced half. Validation is where most “RDF stacks” stop at the basics. 0.3.1 completes SHACL Advanced Features (SHACL-AF) in oxirs-shacl: recursive shapes and qualified value shapes, plus a dedicated rule-based reasoning engine — a reasoning validator with its own reasoning types and validation rules for RDFS / OWL 2 RL-style entailment. On top of that, oxirs-shacl-ai adds a genetic algorithm (optimization/genetic.rs) that searches for the cheapest constraint evaluation order — configurable population, generations, tournament size, and mutation rate, scored by a cost estimate.

RDF-star stops being a parser feature and becomes an engine feature. Quoted triples now flow through the entire oxirs-core query path: query algebra, the executor, the JIT, the planner, pattern unification, and SIMD triple matching all understand << s p o >>. You can pattern-match on statements about statements and have the optimizer reason about them, not just round-trip them through Turtle-star.

The C crypto vanishes. 0.3.1 finishes a migration that has been in flight across the 0.3.x line. Every dependency that used to drag in C or assembly is now Pure Rust:

The net result, stated in the release’s own words: the default cargo build is now free of ring and aws-lc-sys/aws-lc-rs C/asm crypto.

This all lands at ~43,500 tests across the workspace, zero warnings, with every .rs file under 2,000 lines.

Technical Deep Dive: what’s new under the hood

1. Reasoning, not just checking. SHACL-AF’s rule-based reasoning engine is the headline of the validation tier. Combined with recursive and qualified value shapes, OxiRS can now express and enforce constraints that depend on entailed triples — closing the gap with the most capable SHACL processors. The genetic constraint-order optimizer then makes large shape graphs practical to validate by minimizing evaluation cost.

2. Inductive embeddings with GraphSAGE. oxirs-embed adds models/graph_sage.rs — a GraphSageEmbedder doing k-hop mean aggregation with ReLU + L2-normalization, Xavier initialization via scirs2-core, margin ranking loss, sign-SGD, and LCG neighbor sampling. Unlike transductive embeddings, it produces vectors for unseen entities — embed a node that wasn’t in the training graph.

3. GraphRAG that explains and adapts. oxirs-graphrag gains a GraphSummarizer (summarizer.rs) that runs Leiden community detection → in-degree centrality → predicate-frequency analysis and emits a natural-language to_text() summary of a graph. A new TripleRelevanceFeedback (feedback.rs) re-ranks results with multiplicative weight adjustment (clamped 0.1–2.0) and seahash-based triple IDs.

4. New formats and security boundaries. oxirs-ttl adds an HDT 1.0 (Header-Dictionary-Triples) binary reader and a streaming TriG pull-parser (TriGStreamingParser as an Iterator). oxirs-fuseki and oxirs-did gain a FIPS 140-2 fips feature gate for FIPS-validated cryptography, backed by RFC-003’s FIPS boundary policy, and oxirs-fuseki adds RBAC policy templates — a PolicyTemplateRegistry with built-in DBA, ReadOnly, and Auditor roles (18 tests).

5. The dependency floor moves up. SciRS2 jumps 0.4.3 → 0.5.0 across all 12 sub-crates, and the OxiARC compression family is pinned to 0.3.3 and consumed directly from crates.io — the temporary path overrides are gone. (That 0.3.3 release fixed an oxiarc-brotli incompressible-input bug found while migrating OxiRS, and shipped upstream the same day.)

Getting Started

Install the CLI:

cargo install oxirs

Validate a graph against SHACL shapes and serve it:

oxirs init mykg
oxirs import mykg data.ttl --format turtle
oxirs query mykg "SELECT * WHERE { ?s ?p ?o } LIMIT 10"
oxirs serve mykg/oxirs.toml --port 3030

Embedding the engine and want quoted-triple support in your own code? Add the core crate:

cargo add oxirs-core

RDF-star quoted triples now participate in pattern matching directly:

use oxirs_core::query::QueryEngine;

// Match statements *about* statements: who asserted that Alice knows Bob?
let q = "SELECT ?who WHERE { << ?a foaf:knows ?b >> ex:assertedBy ?who }";
let results = QueryEngine::new(&store).execute(q)?;

What’s New in 0.3.1

Tips

This is the foundation

OxiRS is part of the COOLJAPAN ecosystem of Pure-Rust infrastructure, and 0.3.1 is the release where that principle becomes total for the crypto and compression stack. It rides on SciRS2 (now 0.5.0) for graph analytics and numerics, routes all compression through the OxiARC family (oxiarc-brotli, oxiarc-snappy, oxiarc-deflate, pinned to 0.3.3), and now handles every hash, MAC, AEAD, KDF, and RNG through OxiCrypto, with transport secured by OxiTLS. Alongside siblings like OxiZ (SMT) and OxiRAG, OxiRS gives you an end-to-end auditable, JVM-free, C-free path from bytes on disk to a reasoned SPARQL answer.

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

Star the repo if you want a knowledge graph whose entire crypto and compression stack you can read in Rust. Pure Rust Semantic Web is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ June 7, 2026

↑ Back to all posts