Oxiland

Release status: repository tip 0.13.0 retains demonstrated Redland parity and carries the performance-optimized C compatibility paths.

Performance: tip closed the ADR-028 competitive-parity gate and the ADR-029 suite-wide faster-than-Redland gate (Linux, macOS, and Windows × three independent strict runs). See Performance.

Oxiland is an embedded RDF toolkit for Rust and Python. It provides validated RDF terms, in-memory and persistent datasets, named graphs, SPARQL 1.1, and streaming RDF input and output through a compact, typed API—without running a database server.

Tip 0.13.0 retains the demonstrated Redland-parity gate defined in the 0.11 milestone and adds the optimized performance candidate. See the parity report, 0.12 performance report, 0.13 suite-wide report, and parity ledger.

Oxiland uses Oxigraph 0.5.9 for standards-oriented RDF and SPARQL execution and Fjall for its supported durable store. The primary Rust crate forbids unsafe code.

Capabilities

• RDF named nodes, blank nodes, literals, triples, quads, and graph names;
• default-graph and named-graph CRUD with lazy pattern matching;
• process-local in-memory models and local persistent format-v1 stores;
• atomic write transactions, explicit sync, read-only open, and N-Quads backup;
• SPARQL ASK, SELECT, CONSTRUCT, DESCRIBE, and Update;
• streaming Turtle, N-Triples, N-Quads, TriG, and RDF/XML parsing;
• RDF and SPARQL result serialization;
• digest, IRI, file-URI, Unicode, namespace, vocabulary, and logging utilities;
• Python wheels for CPython 3.10–3.14 with bundled type information;
• C Redland-shaped surface (oxiland-capi) with librdf-compat packaging;
• Redland workflow migration guidance and inventory-backed compatibility claims.

Install

Rust

Oxiland requires Rust 1.87 or newer.

Published release (crates.io):

[dependencies]
oxiland = "0.13.0"

This repository tip (0.13.0 APIs and qualification tooling):

[dependencies]
oxiland = { git = "https://github.com/eddiethedean/oxiland" }

Enable tracing only when World log records should also be emitted as tracing events:

[dependencies]
oxiland = { version = "0.13.0", features = ["tracing"] }

Python

python -m pip install oxiland

Released wheels support CPython 3.10–3.14 on the published platform matrix and have no required Python dependencies. See the Python installation guide.

Command line

cargo install oxiland-cli
oxiland-cli --help

Installs the latest published CLI from crates.io.

C ABI (tip only)

Not published to crates.io (publish = false). Clone this repository, then:

cargo build -p oxiland-capi --release

See the C ABI guide.

Rust quick start

use oxiland::terms::{Literal, Triple, named_node};
use oxiland::{Model, Query, QueryResults};

fn main() -> oxiland::Result<()> {
    let model = Model::new()?;
    model.add(Triple::new(
        named_node("https://example.com/alice")?,
        named_node("https://schema.org/name")?,
        Literal::new_simple_literal("Alice"),
    ))?;

    let result = Query::new("ASK { ?s ?p ?o }").execute(&model)?;
    assert!(matches!(result, QueryResults::Boolean(true)));
    Ok(())
}

Model::add returns true when the dataset changed and false when the same statement was already present.

Python quick start

from oxiland import Literal, Model, NamedNode, Triple, query

model = Model()
model.add(
    Triple(
        NamedNode("https://example.com/alice"),
        NamedNode("https://schema.org/name"),
        Literal("Alice"),
    )
)

assert query(model, "ASK { ?s ?p ?o }") is True

The Python documentation track covers installation, models, RDF I/O, SPARQL, production operations, and the complete public API.

Persistence and transactions

use oxiland::terms::{Literal, Triple, named_node};
use oxiland::Model;

fn main() -> oxiland::Result<()> {
    let model = Model::open("./data/catalog")?;

    model.transaction(|tx| {
        tx.add(Triple::new(
            named_node("https://example.com/item/42")?,
            named_node("https://schema.org/name")?,
            Literal::new_simple_literal("Desk lamp"),
        ))?;
        Ok(())
    })?;

    model.sync()?;
    model.export_nquads_to_path("./backups/catalog.nq")?;
    Ok(())
}

Persistent stores are embedded local state, not a network database. Applications own store-directory permissions, lifecycle, capacity, backups, and service-level concurrency. Read the Rust production guide before deploying a durable model.

RDF formats

Unknown formats and ambiguous aliases fail with Error::Unsupported. Oxiland does not silently guess syntax from document contents.

Documentation

Published guides are available at oxiland.readthedocs.io.

Compatibility and scope

Oxiland supports Redland-shaped concepts and migration workflows. Tip 0.13.0 ships oxiland-capi with demonstrated source and librdf-compat binary evidence on the frozen matrix—see limitations for remaining behavioral gaps. The Python package is not an rdflib adapter. Every compatibility statement is scoped by subsystem, platform, and evidence in the parity ledger.

Choose Oxigraph directly when only its native engine API is required. Choose Oxiland when its stable facade, explicit unsupported errors, persistent-store contract, Python package, CLI, C surface, or Redland migration evidence adds value.

Stability and support

Oxiland is pre-1.0. Minor 0.x releases may contain documented public API changes. Persistent format v1 is reopen-compatible across 0.4.x–0.13.x patch lines; export N-Quads before any future format-v2 migration. See the support policy and changelog.

Milestone 0.11 demonstrated Redland parity on the frozen matrix. Tip closed the ADR-028 competitive-parity gate and the ADR-029 suite-wide faster-than-Redland gate (three independent corrected-runner passes on Linux, macOS, and Windows). See performance and the ROADMAP for version 1.0 readiness.

Report suspected vulnerabilities privately according to SECURITY.md, not in a public issue.

Development

cargo fmt --all --check
cargo fmt --manifest-path python/Cargo.toml --check
cargo fmt --manifest-path fuzz/Cargo.toml --check
cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
cargo clippy --manifest-path python/Cargo.toml --all-targets --locked -- -D warnings
cargo clippy --manifest-path fuzz/Cargo.toml --all-targets --locked -- -D warnings
cargo test --workspace --all-features --locked
cargo doc --workspace --all-features --no-deps --locked
python3 scripts/check-inventory.py
python3 scripts/check-docs.py
scripts/generate-public-api.sh check

Python contributors should also run the package's pytest, Pyright, examples, and wheel checks described in CONTRIBUTING.md.

License

Licensed under either Apache-2.0 or MIT, at your option.