Oxiland

Release status: crates.io and PyPI currently publish 0.7.0 (see badges). This repository tip is 0.8.0 (unreleased). Use registry pins for the last published release, or depend on this git checkout for tip APIs.

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.8.0 adds three published-style surfaces plus a build-from-source C preview:

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 a frozen allowlist (tip 0.8);
• 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.7.0"

This repository tip (0.8.0 APIs, including sealed storage selection):

[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.7.0", features = ["tracing"] }

Python

python -m pip install oxiland

Published wheels are 0.7.0 until the 0.8 tag ships. They support CPython 3.10–3.14 on the released platform matrix and have no required Python dependencies. See the Python installation guide.

Command line

cargo install oxiland-cli
oxiland-cli --help

Installs the last published CLI from crates.io (0.7.0 today).

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.8.0 ships a C source-compat preview (oxiland-capi) for a frozen allowlist—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.8.x patch lines; export standards RDF before major upgrades. See the support policy and changelog.

Until v0.8.0 is tagged, registry installs remain 0.7.0 while this tip documents 0.8 APIs.

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.