Oxiland

Release status: tip 0.10.0 has passed the checked-in qualification bundle (scripts/check-0.10-release.py). Tag and publish when packaging attestation and crates.io/PyPI workflows are run for v0.10.0. Milestone 0.11 is now the active full-Redland-parity phase; 0.10's bundle is qualification scaffolding, not a full behavioral/source/binary parity claim.

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.10.0 freezes the intended 1.0 storage contract and adds strict release-qualification tooling. It does not yet claim full Redland parity; the 0.11 milestone defines the native evidence required to make that claim.

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 source-compat preview (oxiland-capi) for an expanded allowlist;
• 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.9.0"

This repository tip (0.10.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.9.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 preview (tip only)

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

cargo build -p oxiland-capi --release

See the C ABI preview 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.10.0 ships an expanded C source-compat preview (oxiland-capi)—it is not an ABI drop-in for existing Redland binaries. 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 preview, 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.10.x patch lines; export standards RDF before major upgrades. See the support policy and changelog.

The full-Redland-parity and 1.0 claims remain blocked on the native evidence required by milestone 0.11.

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.