Rust API

This page links to the generated Rust API documentation for every crate in the xlog workspace, plus hosted fallbacks for the crates published to crates.io. “rustdoc” is Rust’s standard tool for turning source comments into browsable HTML API reference. The docs build generates rustdoc for the full workspace in a temporary build directory, then attaches it to the exported site at /generated/rust/ after the Mintlify export step. This keeps the generated Rustdoc HTML out of the Mintlify source tree while still publishing the generated API with the site. The CI docs build uses a rustdoc-only CUDA artifact mode: it documents the Rust API surface without compiling PTX or cubin files (the two compiled GPU-code formats that a release build would normally emit).

Workspace rustdoc

Generated index for every documented crate in the current checkout.

Python extension crate

Native Rust layer used by the Python package.

Workspace Crates

Every crate in the xlog source tree, with a link to its generated API docs and a one-line summary of what it owns. Terms in parentheses are the exact type or module names as they appear in the API.

Crate	Generated API	Responsibility
`xlog-core`	rustdoc	Shared types (`ScalarType`, `Schema`, `AggOp`), traits (`KernelProvider`), and common errors.
`xlog-ir`	rustdoc	Relational intermediate-representation nodes — the query plan xlog builds internally (`RirNode`) — plus expressions (`Expr`) and execution plans.
`xlog-cuda`	rustdoc	CUDA provider, GPU buffers, PTX embedding (bundling compiled GPU code into the binary), Arrow IPC/C Data interop (exchanging Apache Arrow columnar data with other tools), and DLPack support (a standard for sharing tensors across frameworks).
`xlog-stats`	rustdoc	Runtime and compiler feedback through `StatsManager` and `StatsSnapshot`.
`xlog-runtime`	rustdoc	Host-side executor, relation stores, profiling, incremental maintenance (updating results as data changes instead of recomputing), and join index caches.
`xlog-logic`	rustdoc	Parser, stratification (ordering rules into evaluation layers so negation and recursion are handled in the right sequence), AST-to-RIR lowering (translating the parsed syntax tree into the relational intermediate representation above), optimization, and neural predicate syntax.
`xlog-solve`	rustdoc	Solver services, including GPU CDCL verification (conflict-driven clause learning, the standard algorithm for deciding Boolean satisfiability) and CLS SAT/MaxSAT paths (SAT = is a Boolean formula satisfiable; MaxSAT = satisfy as many clauses as possible).
`xlog-gpu`	rustdoc	High-level GPU execution API and integration buffers.
`xlog-prob`	rustdoc	Probabilistic provenance (tracking which input facts support each answer), CNF lowering (rewriting a formula into conjunctive normal form, a standard Boolean-formula shape), Decision-DNNF compilation (a compiled form of the formula that makes exact probability counting tractable), exact inference, and sampling.
`xlog-cli`	rustdoc	Command-line execution surface for deterministic and probabilistic runs. The package renders under the Rust crate root `xlog`.
`pyxlog`	rustdoc	Native Python extension crate. It is built for the Python package rather than published to crates.io.
`xlog-neural`	rustdoc	Neural-symbolic rule learning implementation. It is not a published crates.io package.
`xlog-induce`	rustdoc	Exact induction implementation. It is not a published crates.io package.
`xlog-cuda-tests`	rustdoc	CUDA-facing workspace test crate. It is not a published crates.io package.
`xlog-integration`	rustdoc	Integration test crate. It is not a published crates.io package.

Breaking changes

Changes on this list stop downstream Rust code from compiling. Each entry names the release it landed in and the edit that fixes the call site.

0.12.0 — `xlog-runtime`

ExecutionStats and StratumStats — the two structs behind xlog run --stats — are now #[non_exhaustive]. Code outside xlog-runtime can no longer build either one from a struct literal, and can no longer match all of its fields exhaustively. Two edits fix a call site:

// Construct: start from Default and override the fields you set.
let stats = ExecutionStats { ..Default::default() };

// Match: add a `..` arm so future fields do not break the pattern.
let ExecutionStats { total_duration_us, .. } = stats;

In exchange, later releases can add counter fields without breaking the API again. The field names and values that --stats prints are unchanged, so anything that only reads the CLI output is unaffected.

0.12.0 — `xlog-logic`

Two public functions in xlog_logic::epistemic now return a fallible result instead of a bare Program:

reduce_epistemic_program_to_ordinary(&Program) -> Result<Program>
reduce_epistemic_program_to_ordinary_for_stratified_schema(&Program) -> Result<Program>

Both previously returned Program directly. The reduction can now fail — for example when an augmenting modal cannot be resolved — and reports that instead of producing a program that would fail later. Result here is xlog_core::Result, whose error type is XlogError. One edit fixes a call site:

// Before: the reduced program came back directly.
let reduced = reduce_epistemic_program_to_ordinary(&program);

// After: propagate the error, or handle it.
let reduced = reduce_epistemic_program_to_ordinary(&program)?;

0.12.0 — `xlog-prob`

ChoiceSource::choices — on the struct re-exported at the xlog_prob crate root — is retyped from Vec<(GroundAtom, f64)> to Arc<[(GroundAtom, f64)]>. A k-head annotated disjunction now pays for one shared k-length slice rather than one clone per Bernoulli chain variable. Struct literals and any Vec-only method call (push, truncate, extend) stop compiling. Indexing, len(), iter(), and slice patterns are unaffected. Two edits fix a call site:

use std::sync::Arc;

// Construct: convert the vector into the shared slice.
let source = ChoiceSource {
    choices: Arc::from(pairs),          // pairs: Vec<(GroundAtom, f64)>
    choice_index,
    source_id,
};

// Mutate: build the full vector first, then share it — the field is no
// longer growable in place.
let mut pairs = Vec::new();
pairs.push((atom, p));
let choices: Arc<[(GroundAtom, f64)]> = Arc::from(pairs);

Published Crates

These crates are published on crates.io and also have hosted docs.rs pages:

Crate	docs.rs
`xlog-core`	docs.rs
`xlog-ir`	docs.rs
`xlog-cuda`	docs.rs
`xlog-stats`	docs.rs
`xlog-runtime`	docs.rs
`xlog-logic`	docs.rs
`xlog-solve`	docs.rs
`xlog-gpu`	docs.rs
`xlog-prob`	docs.rs
`xlog-cli`	docs.rs

docs.rs builds can omit CUDA-gated modules because the hosted build environment has no CUDA toolkit or GPU. The generated site rustdoc is built from the current checkout with XLOG_RUSTDOC_NO_CUDA=1 cargo doc --workspace --no-deps --locked, so it is the reference API surface for this documentation site. Release builds still require nvcc and CUDA Toolkit 13.x to compile kernel artifacts.

See the architecture overview for how these crates fit together, and the CLI Reference for the command-line surface built on top of them.

Language

Tooling

Configuration

APIs

Workspace rustdoc

Python extension crate

Workspace Crates

Breaking changes

0.12.0 — `xlog-runtime`

0.12.0 — `xlog-logic`

0.12.0 — `xlog-prob`

Published Crates

Workspace rustdoc

Python extension crate

​Workspace Crates

​Breaking changes

​0.12.0 — xlog-runtime

​0.12.0 — xlog-logic

​0.12.0 — xlog-prob

​Published Crates

Workspace Crates

Breaking changes

0.12.0 — `xlog-runtime`

0.12.0 — `xlog-logic`

0.12.0 — `xlog-prob`

Published Crates