OxiRS 0.1.0 Released — A Rust-Native Apache Jena, First Stable Cut

The knowledge graph stack just lost its JVM.

Today we released OxiRS 0.1.0 — the first stable cut of a Rust-native, modular platform for the Semantic Web, SPARQL 1.2, GraphQL, and AI-augmented reasoning.

No JVM. No CLASSPATH. No tuning four garbage-collector flags before your triple store will stay up under load. For two decades, serious RDF and SPARQL work has meant Apache Jena and Fuseki — excellent software, but software that drags an entire Java runtime, its startup cost, and its memory profile into every deployment. OxiRS rebuilds that world in Rust: a single static binary you can drop onto a server, a container, or the edge, with predictable memory and no warm-up.

Why 0.1.0 matters

Jena is the reference implementation almost everyone reaches for, and the things that make it heavy are the same things that make it trusted: a full algebra engine, an HTTP protocol layer, a storage backend, reasoning, SHACL. To replace it you cannot ship a toy. So 0.1.0 is deliberately a complete first release rather than a sketch:

• Complete SPARQL 1.1/1.2 — SELECT, CONSTRUCT, ASK, DESCRIBE, plus INSERT/DELETE updates, with W3C-compliant semantics. SPARQL 1.2 extensions (RDF-star, enhanced property paths, advanced aggregations) are in from day one.
• An adaptive query optimizer that detects query complexity and takes a fast path for simple patterns. The CHANGELOG reports the optimizer profiles converging to roughly 3.0 µs (down from 10–16 µs) — a 3.3x–5.3x speedup depending on profile, on a 5-pattern benchmark.
• A Fuseki-compatible HTTP server (oxirs-fuseki) so existing SPARQL clients and tooling keep working, plus a GraphQL endpoint (oxirs-gql) over the same dataset — protocol choice, not lock-in.
• 13,123 tests passing at release, with zero compilation warnings enforced across all 22 crates. That number is the honest measure of how much surface area this first release actually covers.

This is an early 0.1.0 and it reads like one in the right places — PREFIX handling in the CLI query path, for instance, is still landing. But the core is real, and it is fast.

Technical Deep Dive: a workspace, not a monolith

OxiRS ships as a Cargo workspace of focused crates. Each one stands alone; you opt into the heavy machinery through dependencies and Cargo features instead of inheriting it all.

• Core & parsing — oxirs-core is the RDF 1.2 data model and SPARQL surface. Seven format parsers (Turtle, N-Triples, RDF/XML, JSON-LD, N-Quads, TriG, N3) cover the formats real datasets arrive in. oxirs-ttl, oxirs-star, and oxirs-vec round out Turtle/TriG, RDF-star, and vector-index abstractions.
• Engine — oxirs-arq is the Jena-style algebra engine with cost-based optimization; oxirs-rule does forward/backward RDFS/OWL/SWRL reasoning; oxirs-shacl implements SHACL Core + SHACL-SPARQL and passes 27/27 of the W3C test cases it targets; oxirs-geosparql brings OGC GeoSPARQL 1.1 with spatial indexing.
• Storage & distribution — oxirs-tdb is a TDB2-compatible MVCC store with memory-mapped optimization and background compaction; oxirs-cluster adds Raft-backed replication; oxirs-stream does Kafka/NATS I/O with RDF Patch and SPARQL Update deltas; oxirs-federate plans SPARQL SERVICE federation.
• Industrial & AI — because knowledge graphs increasingly live next to machines: oxirs-tsdb (time-series with Gorilla compression), oxirs-modbus, and oxirs-canbus (J1939) bridge PLCs and vehicles into RDF; oxirs-embed, oxirs-graphrag, oxirs-shacl-ai, and oxirs-chat cover graph embeddings, GraphRAG retrieval, shape learning, and LLM-augmented querying. Numerical work routes through SciRS2 rather than a C/Fortran BLAS, keeping the default build Pure Rust.

Getting Started

The library lives on crates.io as oxirs-core:

cargo add oxirs-core

Prefer to drive a dataset from the shell? Install the CLI:

# Install the CLI tool
cargo install oxirs --version 0.1.0

# Initialize a new knowledge graph
oxirs init mykg

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

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

# Start the Fuseki-style server
oxirs serve mykg/oxirs.toml --port 3030

Then open http://localhost:3030 for the admin UI, or http://localhost:3030/graphql for GraphiQL if you enabled the GraphQL endpoint.

What’s inside

• RDF 1.2 + 7 format parsers — Turtle, N-Triples, RDF/XML, JSON-LD, N-Quads, TriG, N3.
• SPARQL 1.1 + 1.2 — full query and update, with RDF-star, enhanced property paths, and advanced aggregations.
• Adaptive query optimizer — automatic complexity detection, fast path for ≤5-pattern queries, full cost-based optimization for the hard ones.
• oxirs-fuseki — SPARQL 1.1/1.2 HTTP server with Fuseki-compatible configuration, plus REST API v2 (OpenAPI 3.0 / Swagger UI) and WebSocket subscriptions.
• oxirs-gql — GraphQL over the same RDF dataset.
• SHACL — Core + SHACL-SPARQL validation in oxirs-shacl.
• Reasoning & federation — RDFS/OWL/SWRL rules and 2-phase-commit SPARQL federation.
• Persistent storage — N-Quads on disk with automatic save/load; TDB2-compatible MVCC backend.
• Industrial connectivity — time-series (40:1 Gorilla compression, 500K pts/sec writes), Modbus TCP/RTU, and CANbus/J1939 with SAMM Aspect Model generation.
• AI building blocks — KG embeddings (TransE, ComplEx, Tucker), GraphRAG, AI-assisted SHACL, and a RAG chat API.
• Security & trust — oxirs-did (W3C DID Core 1.0 + VC Data Model 2.0, Ed25519, RDFC-1.0 canonicalization), ReBAC graph authorization, OAuth2/OIDC/JWT.
• WASM — oxirs-wasm runs an in-memory RDF store in the browser with TypeScript definitions and no Tokio dependency.

Tips

• You don’t need the whole platform. Each crate publishes independently. Want just the parsers and data model? Depend on oxirs-core. Want SHACL without a server? Pull in oxirs-shacl. Reach for oxirs-fuseki only when you actually want the HTTP endpoint.
• Expose SPARQL and GraphQL from one dataset. Run oxirs-fuseki for SPARQL clients and tooling, and enable oxirs-gql for application teams that prefer GraphQL — both read the same triples, so you don’t have to choose a query language project-wide.
• Persistence is automatic. oxirs import writes to mykg/data.nq and oxirs query loads it back; there’s no explicit save/load step to forget. Keep dataset names to alphanumerics, _, and -.
• Lean on the optimizer’s fast path. Simple queries (≤5 patterns) skip the full cost-based planner — keeping hot lookups small and selective is what makes them land in the ~3 µs range.
• For industrial data, generate the model. oxirs canbus to-samm derives a SAMM Aspect Model from a DBC file, and the Modbus/CANbus bridges emit triples with QUDT units and PROV-O timestamps, so machine data arrives already typed and provenanced.

This is the foundation

OxiRS 0.1.0 joins a growing family of Pure Rust infrastructure from COOLJAPAN. Its numerical core is built on SciRS2 (the scientific-computing stack standing in for NumPy/SciPy), and its binary serialization uses Oxicode in place of bincode — both already shipped and both keeping OxiRS free of C and Fortran in its default build. The goal across the ecosystem is the same: domain platforms that compile to a single static binary, run anywhere Rust runs, and answer to no external runtime.

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

Star the repo if a JVM-free, single-binary knowledge graph engine is something you’ve been waiting for — and file the rough edges you hit, because this is 0.1.0 and your reports shape 0.2.

Pure Rust Semantic Web is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ January 21, 2026