Oxiland

Release status: tip 0.11.0 demonstrates Redland parity on the frozen matrix (six native differential cells, C corpus, librdf-compat packaging). Reproduce with scripts/check-0.11-release.py against compatibility/qualification/.

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.11.0 closes the demonstrated Redland-parity gate defined in the 0.11 milestone. See the parity 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.11.0"

This repository tip (0.11.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.11.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.11.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.11.x patch lines; export standards RDF before major upgrades. See the support policy and changelog.

Milestone 0.11 demonstrated Redland parity on the frozen matrix; version 1.0 still requires the readiness gates in ROADMAP.

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

Development

cargo fmt --check
cargo clippy --all-targets -- -D warnings
cargo test
cargo doc --no-deps
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.