OxiRS

June 6, 2026 · View on GitHub

A Rust-native, modular platform for Semantic Web, SPARQL 1.2, GraphQL, and AI-augmented reasoning

Status: v0.3.1 - Released - 2026-06-06

Production Ready: Complete SPARQL 1.1/1.2 implementation with 3.8x faster optimizer, industrial IoT support, and AI-powered features. ~43,500 tests passing with zero warnings across all 26 crates.

v0.3.1 Highlights (2026-06-06): SHACL Advanced Features (recursive + qualified value shapes + a rule-based reasoning engine), genetic constraint-order optimization, RDF-star quoted triples in pattern matching and query execution, GraphSAGE inductive embeddings, graph summarizer and relevance feedback, FIPS 140-2 feature gates (oxirs-fuseki, oxirs-did), and RBAC policy templates. Completes the COOLJAPAN Pure-Rust migration (brotli/snap/flate2 → oxiarc, ring → oxicrypto, pure-Rust TLS via oxitls): the default cargo build now links zero ring/aws-lc-sys C/asm crypto. SciRS2 0.5.0; oxiarc 0.3.3 consumed directly from crates.io.

Vision

OxiRS aims to be a Rust-first, JVM-free alternative to Apache Jena + Fuseki and to Juniper, providing:

Protocol choice, not lock-in: Expose both SPARQL 1.2 and GraphQL endpoints from the same dataset
Incremental adoption: Each crate works stand-alone; opt into advanced features via Cargo features
AI readiness: Native integration with vector search, graph embeddings, and LLM-augmented querying
Single static binary: Match or exceed Jena/Fuseki feature-for-feature while keeping a <50MB footprint

Quick Start

Installation

# Install the CLI tool
cargo install oxirs

# Or build from source
git clone https://github.com/cool-japan/oxirs.git
cd oxirs
cargo build --workspace --release

What's New in v0.3.1 (2026-06-06)

Maintenance & Hardening Release: SHACL-AF, Pure-Rust Migration, and Inductive Embeddings

OxiRS v0.3.1 completes SHACL Advanced Features, finishes the COOLJAPAN Pure-Rust migration, and adds new AI and security capabilities:

SHACL Advanced Features (SHACL-AF) - Recursive shapes, qualified value shapes, and a rule-based reasoning engine (RDFS / OWL 2 RL entailment)
SHACL constraint-order optimization - Genetic algorithm (configurable population/generations/tournament/mutation) for shape constraint ordering (oxirs-shacl-ai)
RDF-star in query execution - Quoted triples now flow through pattern matching, query algebra, executor, JIT, planner, and SIMD triple matching
GraphSAGE inductive embeddings - k-hop mean aggregation (ReLU + L2-norm), Xavier init, margin ranking loss, and unseen-entity support (oxirs-embed)
Graph summarizer & relevance feedback - Leiden community detection → centrality → predicate-frequency natural-language summaries, plus multiplicative relevance-feedback re-ranking (oxirs-graphrag)
FIPS 140-2 feature gates - fips feature for FIPS-validated cryptography in oxirs-fuseki and oxirs-did (RFC-003 FIPS boundary policy)
RBAC policy templates - Built-in DBA / ReadOnly / Auditor role templates via PolicyTemplateRegistry (oxirs-fuseki)
Pure-Rust migration complete - Compression (brotli/snap/flate2 → oxiarc), crypto (ring → oxicrypto), and TLS (pure-Rust oxitls provider); the default cargo build links zero ring / aws-lc-sys C/asm crypto
Dependency refresh - SciRS2 0.5.0; oxiarc 0.3.3 now consumed directly from crates.io; large-file refactors keep every source file under 2,000 lines

Quality Metrics (v0.3.1):

✅ ~43,500 tests passing (100% pass rate)
✅ Zero compilation warnings across all 26 crates
✅ Pure Rust by default - zero ring / aws-lc-sys in the default-feature build
✅ All .rs files under 2,000 lines (proactive refactors applied)

What's New in v0.3.0 (May 3, 2026)

Major Feature Release: 26 New Modules Across 16 Development Rounds

OxiRS v0.3.0 significantly expands the platform with deep SPARQL algebra, production storage, AI capabilities, and security hardening:

Core Capabilities:

Complete SPARQL 1.1/1.2 - Full W3C compliance with advanced query optimization
3.8x Faster Optimizer - Adaptive complexity detection for optimal performance
Advanced SPARQL Algebra - EXISTS/MINUS evaluators, subquery builder, service clause, LATERAL join
Industrial IoT - Time-series, Modbus, CANbus/J1939 integration
AI-Powered - GraphRAG, vector store, constraint inference, conversation history, thermodynamics
Production Security - ReBAC, OAuth2/OIDC, DID & Verifiable Credentials, trust chain validation
Storage Hardening - Six-index store, index merger/rebuilder, triple cache, shard router
Complete Observability - Prometheus metrics, OpenTelemetry tracing
Cloud Native - Kubernetes operator, Terraform modules, Docker support

Quality Metrics (v0.3.0):

✅ 40,786 tests passing (100% pass rate, ~115 skipped)
✅ Zero compilation warnings across all 26 crates
✅ 95%+ test coverage and documentation coverage
✅ Production validated in industrial deployments
✅ 26 new functional modules added across 16 development rounds
✅ Production unwrap() audit: all 18,554 unwrap() calls confirmed in test blocks (zero production violations)
✅ Security advisories reviewed: RUSTSEC-2026-0002 (lru via tantivy) documented as not exploitable

Usage

# Initialize a new knowledge graph (alphanumeric, _, - only)
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"

# Query with specific patterns
oxirs query mykg "SELECT ?name WHERE { ?person <http://xmlns.com/foaf/0.1/name> ?name }"

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

Features:

✅ Persistent storage: Data automatically saved to disk in N-Quads format
✅ SPARQL queries: SELECT, ASK, CONSTRUCT, DESCRIBE supported
✅ Auto-load: No manual save/load needed
🚧 PREFIX support: Coming in next release

Open:

http://localhost:3030 for the Fuseki-style admin UI
http://localhost:3030/graphql for GraphiQL (if enabled)

Published Crates

All crates are published to crates.io and documented on docs.rs.

Core

Crate	Version	Docs	Description
oxirs-core			Core RDF and SPARQL functionality

Server

Crate	Version	Docs	Description
oxirs-fuseki			SPARQL 1.1/1.2 HTTP server
oxirs-gql			GraphQL endpoint for RDF

Engine

Crate	Version	Docs	Description
oxirs-arq			SPARQL query engine
oxirs-rule			Rule-based reasoning
oxirs-shacl			SHACL validation
oxirs-samm			SAMM metamodel & AAS
oxirs-geosparql			GeoSPARQL support
oxirs-star			RDF-star support
oxirs-ttl			Turtle parser
oxirs-vec			Vector search

Storage

Crate	Version	Docs	Description
oxirs-tdb			TDB2-compatible storage
oxirs-cluster			Distributed clustering

Stream

Crate	Version	Docs	Description
oxirs-stream			Real-time streaming
oxirs-federate			Federated queries

AI

Crate	Version	Docs	Description
oxirs-embed			Knowledge graph embeddings & vector store
oxirs-shacl-ai			AI-powered SHACL constraint inference
oxirs-chat			RAG chat API with conversation history
oxirs-physics			Physics-informed digital twin reasoning
oxirs-graphrag			GraphRAG hybrid search (Vector x Graph)

Security

Crate	Version	Docs	Description
oxirs-did			DID & Verifiable Credentials

Platforms

Crate	Version	Docs	Description
oxirs-wasm			WASM browser/edge deployment

Tools

Crate	Version	Docs	Description
oxirs (CLI)			CLI tool

Architecture

oxirs/                  # Cargo workspace root
├─ core/                # Thin, safe re-export of oxigraph
│  └─ oxirs-core
├─ server/              # Network front ends
│  ├─ oxirs-fuseki      # SPARQL 1.1/1.2 HTTP protocol, Fuseki-compatible config
│  └─ oxirs-gql         # GraphQL façade (Juniper + mapping layer)
├─ engine/              # Query, update, reasoning
│  ├─ oxirs-arq         # Jena-style algebra + extension points
│  ├─ oxirs-rule        # Forward/backward rule engine (RDFS/OWL/SWRL)
│  ├─ oxirs-samm        # SAMM metamodel + AAS integration (Industry 4.0)
│  ├─ oxirs-geosparql   # GeoSPARQL spatial queries and topological relations
│  ├─ oxirs-shacl       # SHACL Core + SHACL-SPARQL validator
│  ├─ oxirs-star        # RDF-star / SPARQL-star grammar support
│  ├─ oxirs-ttl         # Turtle/TriG parser and serializer
│  └─ oxirs-vec         # Vector index abstractions (SciRS2, native HNSW)
├─ storage/
│  ├─ oxirs-tdb         # MVCC layer & assembler grammar (TDB2 parity)
│  └─ oxirs-cluster     # Raft-backed distributed dataset
├─ stream/              # Real-time and federation
│  ├─ oxirs-stream      # Kafka/NATS I/O, RDF Patch, SPARQL Update delta
│  └─ oxirs-federate    # SERVICE planner, GraphQL stitching
├─ ai/
│  ├─ oxirs-embed       # KG embeddings (TransE, ComplEx…)
│  ├─ oxirs-shacl-ai    # Shape induction & data repair suggestions
│  ├─ oxirs-chat        # RAG chat API (LLM + SPARQL)
│  ├─ oxirs-physics     # Physics-informed digital twins
│  └─ oxirs-graphrag    # GraphRAG hybrid search (Vector × Graph)
├─ security/
│  └─ oxirs-did         # W3C DID & Verifiable Credentials
├─ platforms/
│  └─ oxirs-wasm        # WebAssembly browser/edge deployment
└─ tools/
    ├─ oxirs             # CLI (import, export, star-migrate, bench)
    └─ benchmarks/       # SP2Bench, WatDiv, LDBC SGS

Feature Matrix (v0.3.1)

Capability	Oxirs crate(s)	Status	Jena / Fuseki parity
Core RDF & SPARQL
RDF 1.2 & syntaxes (7 formats)	`oxirs-core`	✅ Stable (2332 tests)	✅
SPARQL 1.1 Query & Update	`oxirs-fuseki` + `oxirs-arq`	✅ Stable (2144 + 2688 tests)	✅
SPARQL 1.2 / SPARQL-star	`oxirs-arq` (`star` flag)	✅ Stable	🔸
Advanced SPARQL Algebra (EXISTS/MINUS/subquery)	`oxirs-arq`	✅ Stable	✅
Persistent storage (N-Quads)	`oxirs-core`	✅ Stable	✅
Semantic Web Extensions
RDF-star parse/serialise	`oxirs-star`	✅ Stable (1628 tests)	🔸 (Jena dev build)
SHACL Core+API (W3C compliant)	`oxirs-shacl`	✅ Stable (2008 tests, 27/27 W3C)	✅
Rule reasoning (RDFS/OWL 2 DL)	`oxirs-rule`	✅ Stable (2072 tests)	✅
SAMM 2.0-2.3 & AAS (Industry 4.0)	`oxirs-samm`	✅ Stable (1409 tests, 16 generators)	❌
Query & Federation
GraphQL API	`oxirs-gql`	✅ Stable (2081 tests)	❌
SPARQL Federation (SERVICE)	`oxirs-federate`	✅ Stable (1397 tests, 2PC)	✅
Federated authentication	`oxirs-federate`	✅ Stable (OAuth2/SAML/JWT)	🔸
Real-time & Streaming
Stream processing (Kafka/NATS)	`oxirs-stream`	✅ Stable (1505 tests, SIMD)	🔸 (Jena + external)
RDF Patch & SPARQL Update delta	`oxirs-stream`	✅ Stable	🔸
Search & Geo
Full-text search (`text:`)	`oxirs-textsearch`	⏳ Planned	✅
GeoSPARQL (OGC 1.1)	`oxirs-geosparql` (`geo`)	✅ Stable (1713 tests)	✅
Vector search / embeddings	`oxirs-vec` (1598 tests), `oxirs-embed` (1345 tests)	✅ Stable	❌
Storage & Distribution
TDB2-compatible storage (six-index)	`oxirs-tdb`	✅ Stable (2005 tests)	✅
Distributed / HA store (Raft)	`oxirs-cluster` (`cluster`)	✅ Stable (1489 tests)	🔸 (Jena + external)
Time-series database	`oxirs-tsdb`	✅ Stable (1127 tests)	❌
AI & Advanced Features
RAG chat API (LLM integration)	`oxirs-chat`	✅ Stable (1195 tests)	❌
AI-powered SHACL constraint inference	`oxirs-shacl-ai`	✅ Stable (1589 tests)	❌
GraphRAG hybrid search (Vector x Graph)	`oxirs-graphrag`	✅ Stable (935 tests)	❌
Physics-informed digital twins	`oxirs-physics`	✅ Stable (1063 tests)	❌
Knowledge graph embeddings (TransE, etc.)	`oxirs-embed`	✅ Stable (1345 tests)	❌
Security & Trust
W3C DID & Verifiable Credentials	`oxirs-did`	✅ Stable (1043 tests)	❌
Trust chain validation	`oxirs-did`	✅ Stable	❌
Signed RDF graphs (RDFC-1.0)	`oxirs-did`	✅ Stable	❌
Ed25519 cryptographic proofs	`oxirs-did`	✅ Stable	❌
Security & Authorization
ReBAC (Relationship-Based Access Control)	`oxirs-fuseki`	✅ Stable	❌
Graph-level authorization	`oxirs-fuseki`	✅ Stable	❌
SPARQL-based authorization storage	`oxirs-fuseki`	✅ Stable	❌
OAuth2/OIDC/SAML authentication	`oxirs-fuseki`	✅ Stable	🔸
Browser & Edge Deployment
WebAssembly (WASM) bindings	`oxirs-wasm`	✅ Stable (858 tests)	❌
Browser RDF/SPARQL execution	`oxirs-wasm`	✅ Stable	❌
TypeScript type definitions	`oxirs-wasm`	✅ Stable	❌
Cloudflare Workers / Deno support	`oxirs-wasm`	✅ Stable	❌
Industrial IoT
Modbus TCP/RTU protocol	`oxirs-modbus`	✅ Stable (1095 tests)	❌
CANbus / J1939 protocol	`oxirs-canbus`	✅ Stable (1125 tests)	❌

Legend:

✅ Stable: Production-ready with comprehensive tests, API stability guaranteed
⏳ Planned: Not yet implemented
🔸 Partial/plug-in support in Jena

Quality Metrics (v0.3.1):

~43,500 tests passing (100% pass rate)
Zero compilation warnings (enforced with -D warnings)
95%+ test coverage across all 26 modules
95%+ documentation coverage
All integration tests passing
Production-grade security audit completed
CUDA GPU support for AI acceleration
3.8x faster query optimization via adaptive complexity detection
Pure Rust by default — zero ring / aws-lc-sys C/asm crypto in the default-feature build

Usage Examples

Dataset Configuration (TOML)

[dataset.mykg]
type      = "tdb2"
location  = "/data"
text      = { enabled = true, analyzer = "english" }
shacl     = ["./shapes/person.ttl"]

# ReBAC Authorization (optional)
[security.policy_engine]
mode = "Combined"  # RbacOnly | RebacOnly | Combined | Both

[security.rebac]
backend = "InMemory"  # InMemory | RdfNative
namespace = "http://oxirs.org/auth#"
inference_enabled = true

[[security.rebac.initial_relationships]]
subject = "user:alice"
relation = "owner"
object = "dataset:mykg"

GraphQL Query (auto-generated)

query {
  Person(where: {familyName: "Yamada"}) {
    givenName
    homepage
    knows(limit: 5) { givenName }
  }
}

Vector Similarity SPARQL Service (opt-in AI)

SELECT ?s ?score WHERE {
  SERVICE <vec:similar ( "LLM embeddings of 'semantic web'" 0.8 )> {
    ?s ?score .
  }
}

Digital Twin Platform Examples

Smart City Sensor (NGSI-LD)

# Create an air quality sensor entity
curl -X POST http://localhost:3030/ngsi-ld/v1/entities \
  -H "Content-Type: application/ld+json" \
  -d '{
    "id": "urn:ngsi-ld:AirQualitySensor:Tokyo-001",
    "type": "AirQualitySensor",
    "location": {
      "type": "GeoProperty",
      "value": {"type": "Point", "coordinates": [139.6917, 35.6895]}
    },
    "temperature": {"type": "Property", "value": 22.5, "unitCode": "CEL"}
  }'

# Query sensors within 5km
curl "http://localhost:3030/ngsi-ld/v1/entities?type=AirQualitySensor&georel=near;maxDistance==5000"

Factory IoT Bridge (MQTT)

use oxirs_stream::backend::mqtt::{MqttConfig, MqttClient, TopicSubscription};

let mqtt_config = MqttConfig {
    broker_url: "mqtt://factory.example.com:1883".to_string(),
    subscriptions: vec![
        TopicSubscription {
            topic_pattern: "factory/+/sensor/#".to_string(),
            rdf_mapping: TopicRdfMapping {
                graph_iri: "urn:factory:sensors".to_string(),
                subject_template: "urn:sensor:{topic.1}:{topic.3}".to_string(),
            },
        }
    ],
};

let client = MqttClient::new(mqtt_config).await?;
client.connect().await?;
client.start_streaming().await?; // Real-time RDF updates

Data Sovereignty Policy (IDS/Gaia-X)

use oxirs_fuseki::ids::policy::{OdrlPolicy, Permission, Constraint};

let policy = OdrlPolicy {
    uid: "urn:policy:catena-x:battery-data:001".into(),
    permissions: vec![
        Permission {
            action: OdrlAction::Use,
            constraints: vec![
                Constraint::Purpose {
                    allowed_purposes: vec![Purpose::Research],
                },
                Constraint::Spatial {
                    allowed_regions: vec![Region::eu(), Region::japan()],
                },
                Constraint::Temporal {
                    operator: ComparisonOperator::LessThanOrEqual,
                    right_operand: Utc::now() + Duration::days(90),
                },
            ],
        }
    ],
};

Physics Simulation (SciRS2 Integration)

use oxirs_physics::simulation::SimulationOrchestrator;

let mut orchestrator = SimulationOrchestrator::new();
orchestrator.register("thermal", Arc::new(SciRS2ThermalSimulation::default()));

// Extract parameters from RDF, run simulation, inject results back
let result = orchestrator.execute_workflow(
    "urn:battery:cell:001",
    "thermal"
).await?;

println!("Converged: {}, Final temp: {:.2}°C",
    result.convergence_info.converged,
    result.state_trajectory.last().unwrap().state["temperature"]
);

Complete Examples: See DIGITAL_TWIN_QUICKSTART.md and examples/digital_twin_factory.rs

Internationalization

📖 Localized README versions:

🇯🇵 日本語 (Japanese) - Society 5.0 / PLATEAU support
🇩🇪 Deutsch (German) - Gaia-X / Industry 4.0 focus
🇫🇷 Français (French) - European data sovereignty

Development

Prerequisites

Rust 1.70+ (MSRV)
Optional: Docker for containerized deployment

Building

# Clone the repository
git clone https://github.com/cool-japan/oxirs.git
cd oxirs

# Build all crates
cargo build --workspace

# Run tests
cargo nextest run --no-fail-fast

# Run with all features
cargo build --workspace --all-features

Feature Flags

Optional features to keep dependencies minimal:

geo: GeoSPARQL support
text: Full-text search with Tantivy
ai: Vector search and embeddings
cluster: Distributed storage with Raft
star: RDF-star and SPARQL-star support
vec: Vector index abstractions

Contributing

We welcome contributions! Please see our Contributing Guide for details.

RFC Process

Design documents go in ./rfcs/ with lazy-consensus and 14-day comment window
All code must pass rustfmt + nightly 2026-01, Clippy --all-targets --workspace -D warnings
Commit sign-off required (DCO 1.1)

Roadmap

Version	Target Date	Milestone	Deliverables	Status
v0.1.0	✅ Jan 7, 2026	Initial Production Release	Complete SPARQL 1.1/1.2, Industrial IoT, AI features, 13,123 tests	✅ Released
v0.2.4	✅ Mar 16, 2026	Deep Feature Expansion	40,786 tests, 26 new modules, 3.8x faster optimizer, advanced SPARQL algebra, AI production-grade	✅ Released
v0.3.0	✅ May 3, 2026	Full-text Search & Scale	Full-text search (Tantivy), 10x performance, multi-region clustering, audit/certification/SSO/marketplace	✅ Released
v0.3.1	✅ 2026-06-06	SHACL-AF & Pure-Rust	SHACL Advanced Features (recursive/qualified/reasoning), genetic constraint optimization, RDF-star in query execution, GraphSAGE embeddings, FIPS gates, full Pure-Rust migration, ~43,500 tests	✅ Released (current)

Current Release: v0.3.1 (2026-06-06)

v0.3.1 Focus Areas:

SHACL Advanced Features (SHACL-AF): recursive shapes, qualified value shapes, rule-based reasoning engine
SHACL constraint-order optimization via genetic algorithm (oxirs-shacl-ai)
RDF-star quoted triples in pattern matching and query execution (algebra/executor/JIT/planner/SIMD)
AI: GraphSAGE inductive embeddings, graph summarizer, relevance feedback
Security: FIPS 140-2 feature gates (oxirs-fuseki, oxirs-did), RBAC policy templates
COOLJAPAN Pure-Rust migration complete: brotli/snap/flate2 → oxiarc, ring → oxicrypto, pure-Rust TLS via oxitls
Dependency refresh: SciRS2 0.5.0, oxiarc 0.3.3 from crates.io; large-file refactors (all source < 2,000 lines)

Previous Release: v0.3.0 (May 3, 2026)

v0.3.0 Focus Areas (16 rounds complete):

Advanced SPARQL algebra: EXISTS/MINUS evaluators, subquery builder, service clause, LATERAL join
Storage hardening: six-index store, index merger/rebuilder, B-tree compaction, triple cache
AI production readiness: vector store, constraint inference, conversation history, response cache
Security hardening: credential store, trust chain validation, key manager, VC presenter
New CLI tools: diff, convert, validate, monitor, profile, inspect, merge commands
Stream enhancements: partition manager, consumer groups, schema registry, dead-letter queue
Time-series: continuous queries, write buffer, tag index, retention management

Sponsorship

OxiRS is developed and maintained by COOLJAPAN OU (Team Kitasan).

If you find OxiRS useful, please consider sponsoring the project to support continued development of the Pure Rust ecosystem.

https://github.com/sponsors/cool-japan

Your sponsorship helps us:

Maintain and improve the COOLJAPAN ecosystem
Keep the entire ecosystem (OxiBLAS, OxiFFT, SciRS2, etc.) 100% Pure Rust
Provide long-term support and security updates

License

OxiRS is licensed under:

See LICENSE for details.

Contact

Issues & RFCs: https://github.com/cool-japan/oxirs
Maintainer: @cool-japan (KitaSan)

Release Notes (v0.3.1)

Full notes live in CHANGELOG.md.

Highlights (2026-06-06)

~43,500 tests passing across all 26 crates
SHACL Advanced Features completed: recursive shapes, qualified value shapes, and a rule-based reasoning engine
Genetic constraint-order optimization for SHACL shapes (oxirs-shacl-ai)
RDF-star quoted triples in pattern matching and query execution (algebra, executor, JIT, planner, SIMD)
GraphSAGE inductive embeddings, graph summarizer, and relevance feedback (oxirs-embed, oxirs-graphrag)
FIPS 140-2 feature gates (oxirs-fuseki, oxirs-did) and RBAC policy templates
Pure-Rust migration complete: brotli/snap/flate2 → oxiarc, ring → oxicrypto, pure-Rust TLS via oxitls; default build links zero ring / aws-lc-sys
SciRS2 0.5.0; oxiarc 0.3.3 consumed directly from crates.io; large-file refactors (all source < 2,000 lines)

Previous Highlights (v0.3.0 — May 3, 2026)

40,786 tests passing across all 26 crates
26 new functional modules added across all 26 crates in 16 development rounds
Advanced SPARQL algebra: EXISTS evaluator, MINUS evaluator, subquery builder, service clause handler
Storage hardening: six-index store (SPO/POS/OSP/GSPO/GPOS/GOPS), index merger/rebuilder, B-tree compaction
AI production-grade: vector store, constraint inference, conversation history, response cache, reranker
Security hardening: credential store, trust chain validation, key manager, VC presenter, proof purpose
New CLI tools: diff, convert, validate, monitor, profile, inspect, merge, query commands
Industrial IoT: Modbus register encoder, CANbus frame validator, signal decoder, device scanner
Geospatial: convex hull (Graham scan), distance calculator, intersection detector, area calculator
Stream processing: partition manager, consumer groups, schema registry, dead-letter queue, watermark tracking

Per-Crate Test Counts (v0.3.1)

Workspace total for v0.3.1: ~43,500 tests passing. The per-crate breakdown below is the last published baseline; v0.3.1's additional ~2,700 tests come from GraphSAGE embeddings, the graph summarizer, relevance feedback, SHACL-AF (recursive/qualified/reasoning), Datalog, Manchester syntax, and related modules. | Crate | Tests | |-------|-------| | oxirs-arq | 2688 | | oxirs-core | 2332 | | oxirs-fuseki | 2144 | | oxirs-gql | 2081 | | oxirs-rule | 2072 | | oxirs-shacl | 2008 | | oxirs-tdb | 2005 | | oxirs-ttl | 1726 | | oxirs-geosparql | 1713 | | oxirs-star | 1628 | | oxirs (tools) | 1615 | | oxirs-vec | 1598 | | oxirs-shacl-ai | 1589 | | oxirs-stream | 1505 | | oxirs-cluster | 1489 | | oxirs-samm | 1409 | | oxirs-federate | 1397 | | oxirs-embed | 1345 | | oxirs-chat | 1195 | | oxirs-tsdb | 1127 | | oxirs-canbus | 1125 | | oxirs-modbus | 1095 | | oxirs-physics | 1063 | | oxirs-did | 1043 | | oxirs-graphrag | 935 | | oxirs-wasm | 858 | | Baseline subtotal | 40,786 |

Performance Benchmarks

Query Optimization (5 triple patterns):
  HighThroughput:  3.24 µs  (3.3x faster than baseline)
  Analytical:      3.01 µs  (3.9x faster than baseline)
  Mixed:           2.95 µs  (3.6x faster than baseline)
  LowMemory:       2.94 µs  (5.3x faster than baseline)

Time-Series Database:
  Write throughput: 500K pts/sec (single), 2M pts/sec (batch)
  Query latency:    180ms p50 (1M points)
  Compression:      40:1 average ratio

Production Impact (100K QPS):
  CPU time saved: 45 minutes per hour (75% reduction)
  Annual savings: \$10,000 - \$50,000 (cloud deployments)

Getting Started

Install the CLI with cargo install oxirs
Adaptive optimization is enabled by default (no configuration needed)
CUDA support is opt-in via feature flags
See CHANGELOG.md for detailed release notes

"Rust makes memory safety table stakes; OxiRS makes knowledge-graph engineering table stakes."

v0.3.1 - Released - 2026-06-06