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.

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

# 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

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)

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

# 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)

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

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

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

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

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

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

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)

Crate	Version	Docs	Description
oxirs-did			DID & Verifiable Credentials

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

Crate	Version	Docs	Description
oxirs (CLI)			CLI tool

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

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

[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"

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

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

# 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"

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

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),
                },
            ],
        }
    ],
};

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

📖 Localized README versions:

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

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

# 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

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

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

• 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)

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)

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

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

OxiRS is licensed under:

See LICENSE for details.

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

Full notes live in CHANGELOG.md.

• ~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)

• 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

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 |

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)

• 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