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

Status: Beta Release (v0.1.0-beta.2) - Released December 21, 2025

⚡ Beta Software: API stability guaranteed. Feature complete for 1.0. Suitable for production use with comprehensive testing.

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 --version 0.1.0-beta.2

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

• CUDA Support: GPU acceleration for knowledge graph embeddings and vector operations.
• Enhanced AI Modules: Improved vision-language graph processing and Tucker decomposition models.
• Performance Improvements: Memory-mapped optimizations for oxirs-tdb storage and enhanced SIMD operations.
• SAMM Enhancements: Performance regression tests and improved metamodel code generation.
• Documentation Updates: Refreshed API documentation and examples across all crates.
• Bug Fixes: Various stability improvements and edge case handling across all modules.

# 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
oxirs-shacl-ai			AI-powered SHACL
oxirs-chat			RAG chat API

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, hnsw_rs)
├─ 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)
└─ tools/
    ├─ oxirs             # CLI (import, export, star-migrate, bench)
    └─ benchmarks/       # SP2Bench, WatDiv, LDBC SGS

Legend:

• ✅ Beta: Production-ready with comprehensive tests, API stability guaranteed
• 🔄 Experimental: Under active development, APIs unstable
• ⏳ Planned: Not yet implemented
• 🔸 Partial/plug-in support in Jena

Quality Metrics (v0.1.0-beta.2):

• 12,248 tests passing (100% pass rate, 100 skipped)
• Zero compilation warnings (enforced with -D warnings)
• 95%+ test coverage across all modules
• 95%+ documentation coverage
• All integration tests passing
• Production-grade security audit completed
• CUDA GPU support for AI acceleration

[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 .
  }
}

• 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 2025-06, Clippy --all-targets --workspace -D warnings
• Commit sign-off required (DCO 1.1)

CUDA & GPU Acceleration:

• ✅ CUDA backend for knowledge graph embeddings
• ✅ GPU-accelerated vector operations
• ✅ Enhanced tensor processing for AI modules

AI Module Improvements:

• ✅ Vision-language graph processing enhancements
• ✅ Tucker decomposition model improvements
• ✅ Enhanced embedding algorithms

Performance & Storage:

• ✅ Memory-mapped file optimizations for oxirs-tdb
• ✅ SIMD operation enhancements
• ✅ SAMM performance regression testing

API Stability & Production Readiness:

• ✅ API stability guarantees with semantic versioning
• ✅ Comprehensive error handling and recovery patterns
• ✅ Production-grade logging and observability
• ✅ Resource management and leak prevention
• ✅ Graceful degradation and fault tolerance

Documentation Excellence:

• ✅ 95%+ documentation coverage across all crates
• ✅ Comprehensive API documentation with examples
• ✅ Migration guides from alpha to beta
• ✅ Production deployment guides
• ✅ Performance tuning documentation

Testing & Quality:

• ✅ 95%+ test coverage across all modules
• ✅ 8,690 tests passing (100% pass rate, 79 skipped)
• ✅ Comprehensive integration test suites
• ✅ Performance benchmarks and stress tests
• ✅ Security testing and vulnerability scanning

Codebase Scale:

• ✅ 1,577,497 lines of Rust across 3,126 files
• ✅ 1.29M lines of production code with 66,158 comments
• ✅ 149,010 lines of inline documentation
• ✅ Comprehensive guides and docs across all modules

Performance Optimization:

• ✅ Query engine optimization and caching
• ✅ Memory usage optimization
• ✅ Parallel processing enhancements
• ✅ Connection pooling and resource management
• ✅ Production performance validation

Security Enhancements:

• ✅ Security audit completed
• ✅ ReBAC (Relationship-Based Access Control) - Production-ready authorization system
  • Google Zanzibar-inspired design with subject-relation-object tuples
  • Graph-level and dataset-level authorization with inheritance
  • Dual backends: In-memory (O(1), 1M relationships) + RDF-native (SPARQL, 10M relationships)
  • REST API (POST/DELETE/GET/BATCH) + CLI tools (export/import/migrate/verify/stats)
  • Permission implication (Manage → Read/Write/Delete) and conditional relationships
  • Unified RBAC+ReBAC policy engine with 4 modes
  • 83 tests passing across all ReBAC components
• ✅ Authentication and authorization hardening
• ✅ Input validation and sanitization
• ✅ Rate limiting and DoS protection
• ✅ Secure defaults and best practices

Focus Areas:

• 🎯 10x query performance improvements
• 🎯 AI features production hardening
• 🎯 Multi-region clustering
• 🎯 Advanced caching strategies
• 🎯 Performance SLAs and guarantees

OxiRS is dual-licensed under either:

• MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)
• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)

at your option.

See LICENSE for details.

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

📄 Full notes live in CHANGELOG.md.

• 🚀 CUDA Support: GPU acceleration for knowledge graph embeddings and AI operations
• 🧠 AI Enhancements: Improved vision-language processing and Tucker decomposition models
• ⚡ Performance: Memory-mapped storage optimizations and enhanced SIMD operations
• 🔧 SAMM Improvements: Performance regression testing and improved code generation
• 📚 Documentation: Updated API docs and examples across all crates
• 🐛 Bug Fixes: Various stability improvements and edge case handling

• Large dataset (>100M triples) performance optimization ongoing
• Full-text search (oxirs-textsearch) planned for v0.3.0
• Advanced AI features continue to mature towards v0.2.0

• ✅ Zero warnings - Strict -D warnings enforced across all 22 crates
• ✅ 12,248 tests passing - 100% pass rate (100 skipped)
• ✅ 95%+ test coverage - Comprehensive test suites
• ✅ 95%+ documentation coverage - Complete API documentation
• ✅ CUDA GPU support - Hardware acceleration for AI
• ✅ Memory-mapped storage - Enhanced I/O performance

• Install the new CLI with cargo install oxirs --version 0.1.0-beta.2
• No Breaking Changes: All beta.1 APIs remain compatible
• New Features: CUDA support is opt-in via feature flags
• Performance: Memory-mapped storage provides automatic improvements
• Existing datasets remain fully compatible
• See CHANGELOG.md for detailed migration guide

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

Beta.2 release - December 21, 2025