Ontologies written as Markdown notes, read and reasoned over by machines.
Try it · CLI · Architecture · Crates · Status · Docs
You keep writing notes the way you already do. A line or two of YAML frontmatter on a note (type: class, subclass-of: ["[[Animal]]"]) turns it into an ontology statement; everything else stays prose. Ontomark parses those notes without losing a byte, builds a typed model from them, reasons over it with an OWL 2 EL engine, compiles it to RDF and the web, and, when asked, lets a language model propose new facts for a note, grounded against the vocabulary the vault already has, with the quote that justifies each one. It is a Rust workspace, compiles to WebAssembly, and runs the same code inside Obsidian as on a server.
Ontomark keeps Markdown as the authoring format and derives a typed graph for software to query. Use it for a personal vault, a research taxonomy, a documentation vocabulary or a governed publication pipeline. The same parser and model support the native toolchain and the worker engine embedded in Obsidian; each host pins its own release.
Three ideas carry the whole design:
- The note is the record. Nothing is re-rendered from a typed view. The only write path is a guarded patch that proves every byte it did not name is unchanged. Explicit IRIs are supported; the generic profile can derive an identifier from the note path. Identity and display labels remain distinct.
- Refusals are named, never silent. The engine implements a profile of OWL 2 EL and reports each construct it cannot reason over. A result that dropped an axiom says so, rather than reporting a classification that is quietly incomplete.
- Models propose, the vault decides. Assisted ingest lets a language model read a note and suggest values, but the model never sees an identifier and never writes: the engine grounds each proposed name against the vault, requires a located quote as evidence, and returns candidates for a human to accept.
If you want to see it work before reading more, install the Obsidian plugin and write the two notes below. If you want to use it as a library, start with ontomark-parse, then ontomark-model; everything else is built on those two. If you are here for the DreamLab estate pipeline, read ADR-OM-005 first and the CLI section below.
Animal.md:
---
type: class
title: Animal
---Dog.md:
---
type: class
subclass-of: ["[[Animal]]"]
---Under the generic profile these are two classes, with Dog a subclass of Animal. Prose links stay navigation; only frontmatter makes axioms. In Obsidian, the plugin indexes, classifies and queries the vault locally, and previews every frontmatter edit as a diff before applying it.
flowchart LR
subgraph write["AUTHORING"]
OB["Obsidian plugin<br/>(ontomark-obsidian)"]
ED["any editor"]
end
VAULT[("Markdown vault<br/>knowledge/ + working/")]
subgraph core["ONTOMARK (this repo)"]
P["parse<br/>lossless Document, guarded Patch"]
M["model<br/>typed entities, IRIs, profiles"]
R["reason<br/>whelk-el, OWL 2 EL, named refusals"]
I["ingest<br/>plan → model → accept"]
C["compile<br/>Turtle, JSON-LD, SHACL, NGG1, site data"]
W["wasm engine"]
CLI["CLI"]
end
subgraph consume["CONSUMERS"]
SITE["published site"]
LOOM["Ontology Loom<br/>reasoned closure, SPARQL"]
VC["VisionClaw<br/>GPU force projection"]
AB["Agentbox agents"]
end
OB & ED --> VAULT --> P --> M --> R
M --> I
R & I --> W --> OB
R --> C --> CLI
CLI -->|"--scope public"| SITE & LOOM & AB
CLI -->|"--scope machine"| VC
Every arrow out of the CLI carries a generation: <prefix>@<commit> (visionGraph@<commit> for the estate; a vault's directory name otherwise) plus a content digest, stamped into each bundle. Generation stamps let a consumer identify the bundle it read. Consumer-specific admission checks determine whether mismatched or stale artefacts are refused; a stamped bundle alone does not prove that every deployed consumer enforces freshness. The estate contract assigns compilation to one producer and makes consumer-specific projections explicit.
| Repository | Role |
|---|---|
| ontomark (here) | The engine: crates, CLI, wasm build, estate profile. The only producer of published bundles. |
| ontomark-obsidian | The desktop plugin. Embeds the wasm engine; offline by default; one optional network call for assisted ingest. |
| DreamLab authoring vault | Private source of the published corpus. Its publishing workflow pins Ontomark; public data is distributed through knowledgeGraph. |
| loom | The Ontology Loom: serves the reasoned closure, SPARQL and grounded answers over a published generation. |
| VisionClaw | The XR/GPU knowledge-graph application. Consumes the machine-scope bundle for its force layout. |
| agentbox | The agent runtime. Bakes the released CLI and routes the grounding skill through it. |
A vault is an ordinary Obsidian vault: notes at the vault root, ids are the root-relative path without .md, and the furniture folders (templates/, bases/, assets/, journals/, .obsidian/) are skipped and reported, never silently dropped (ADR-OM-007). Where the two vault roles live is the profile's layout — knowledge/ and working/ beside ontology/ for the estate, or "." when the repository root is the vault. Point the CLI at any Obsidian vault and it is a repository: ontomark --repo ~/Vaults/Notes validate runs under the generic profile with the built-in vocabulary, builds to Notes@<sha>, and refuses --vault working with exit 2 because that layout has no working vault (ADR-OM-008). The output tree (publish/pages/, publish/working/, reports keyed by role) is the same whatever the input layout.
Install from crates.io, or take the release binary:
cargo install ontomarkEach release ships, built by release.yml from the tagged source, a static Linux x86-64 binary (runs on glibc and Nix hosts alike), a SHA-256 receipt, and the versioned WASM engine bundle the plugin pins.
V=0.7.0
curl -fLO https://github.com/DreamLab-AI/ontomark/releases/download/v$V/ontomark-x86_64-unknown-linux-gnu
curl -fLO https://github.com/DreamLab-AI/ontomark/releases/download/v$V/ontomark-x86_64-unknown-linux-gnu.sha256
sha256sum --check ontomark-x86_64-unknown-linux-gnu.sha256
chmod +x ontomark-x86_64-unknown-linux-gnu && ./ontomark-x86_64-unknown-linux-gnu --help| Command | What it does |
|---|---|
validate |
OKF conformance, vocabulary and link integrity for the selected vaults. |
gate, conflicts |
The autonomous quality gate and the conflict detector, over every selected vault. |
build |
The publication build: Turtle (asserted and inferred), JSON-LD, SHACL, OKF, NGG1 graph tiers, search and scaffold indexes, the page API, a redacted publish/ tree, and the generation marker. |
build --scope machine |
A second bundle for machine consumers: the same ontology artefacts byte for byte, plus the public working/ notes as plain records. Never writes publish/. |
build --with-rvdb |
Also emits data/ontology-corpus.records.jsonl, the portable vector records the Loom promotes into its store. |
build --certificate-out DIR |
Also writes the RDFS derivation certificate of the published graph (oo-cert/1: every inferred triple with its rule and premises), which the independent Lean 4 checker oo-cert re-verifies with no engine. The build is refused if the certificate does not cover the classifier's closure (ADR-OM-009). |
repair, migrate |
Fence and body repairs; registry-driven corpus migrations with plan/apply/rollback. |
ingest |
External sources (files, web pages) to a vault propose bundle: a local model names values and quotes evidence, the page is patched in a manifest, nothing is written to the vault (ADR-OM-010). |
Exit codes are a contract: 0 success, 1 failure, 2 a refusal (a credential in published content, an identity collision, an unsatisfiable corpus, a closure its certificate does not cover, a non-boolean public: flag, an unknown --tier, a scope conflict). Refusals name what they refused.
--repo names either a plain Obsidian vault (no ontology/ folder; the generic profile applies) or an estate-shaped repository holding ontology/vocabulary.yaml, where the estate profile is the default and --profile generic|PATH overrides it. The CLI README has the verbs, exit codes and layout in full.
Each crate has a README and full rustdoc with executable examples. Read them in this order if you are learning the codebase.
| Crate | Version | What it owns |
|---|---|---|
| ontomark-parse | 0.1.3 | The Markdown format: lossless Document, frontmatter and body indexes, the guarded Patch, and the one CommonMark Fence rule every crate uses. |
| ontomark-model | 0.1.2 | Meaning: typed entities, IRIs as identity, predicate forms, reference resolution, pluggable Profile. |
| whelk-el | 0.1.1 | The saturation engine, a Rust port of Whelk, with optional native parallelism. |
| ontomark-reason | 0.1.2 | The OWL 2 EL profile check and classification facade: named refusals, root causes, cancellable sessions. |
| ontomark-ingest | 0.2.1 | Assisted ingest: the pure plan/accept contract, grounding, lexical guards, evidence spans. No I/O, no model. |
| ontomark-source | 0.1.0 | The Source port: local files and URLs as text with a content version, and a ledger that skips unchanged sources. |
| ontomark-jev | 0.7.1 | Opt-in Jev option for ingest (typed Choice/Noul decisions via System One), off by default, exact fallback to the plain path. See its README. |
| rdfs-certificate | 0.1.1 | RDFS forward chaining that records every step in the oo-cert/1 certificate format an independent checker re-verifies, and the consequence delta between two graphs. No graph library; used by ontomark and by VisionClaw's vault. |
| ontomark-compile | 0.8.0 | The publication compiler: emitters, redaction, the two-scope build, vault layout, generation identity, the derivation certificate. |
| ontomark-ngg1 | 0.1.0 | The shared binary graph format and its zero-copy reader. |
| ontomark-profile-estate | 0.8.0 | The DreamLab estate's rules as data; most users want --profile generic and never depend on it. |
| ontomark-wasm | release asset | The worker-friendly engine protocol: index, update, classify, query, patch, ingest. |
| ontomark | 0.8.1 | The installable CLI: cargo install ontomark. ontomark ingest turns external sources into a vault propose bundle. |
| ontomark-ingest-bench | not published | The labelled extraction benchmark: grounding, model and Jev arms, selective-risk curves. |
| ontomark-graph | 0.3.0 | The shared offline graph renderer for desktop and web hosts, with a host-side layout driver. |
Parser, model, reasoner and ingest build for native and wasm32-unknown-unknown. The compiler's portable feature set disables its native backend.
Historical corpus scale and grounding results
The 12 October 2026 snapshot visionGraph@ae913f93 recorded 9,258 typed notes, 13,638 asserted is-a edges and 118,872 subclass statements in the reasoned closure. These describe one corpus generation, not today's corpus size or a benchmark of arbitrary vaults.
Loom's associated held-out question experiments measured answer recall after corpus facts were supplied to a model. They support faithful delivery of curated facts under those test conditions. They do not establish that graph structure improves reasoning over an equal-content control, or that the corpus's claims are externally true. The later copy-control and negative-control work belongs to Loom's research record. Keep experiment populations, model identities and controls with any quoted score.
docs/GROUNDING-EVIDENCE.md tracks the external studies and their verification status. Those studies motivate the design; they are not performance results for this implementation.
Rust 1.89 or later is required by the locked workspace. Install wasm32-unknown-unknown to build the browser engine; x86_64-unknown-linux-musl to build the release binary. The plugin repository builds with Node against a checksum-pinned engine release, independently of this workspace.
cargo build --locked --workspace
cargo test --locked --workspace
cargo clippy --locked --workspace --all-targets -- -D warnings
RUSTDOCFLAGS='-D warnings' cargo doc --locked --workspace --no-deps
cargo build --locked -p ontomark-wasm --target wasm32-unknown-unknown --release
cargo build --locked -p ontomark-ingest --target wasm32-unknown-unknown --releasejust check, just wasm-test and just conformance are the repository gates. CI checks formatting, Clippy, native tests, compiler all/no-default-feature tests, WASM, strict rustdoc, plugin contracts and the complete Git history for secrets. The plugin tests include WASM/native transcript parity and an offline Obsidian API shim; that shim does not substitute for installed-Obsidian acceptance.
Reviewed 5 November 2026. The CLI manifest declares 0.8.1 and the engine 0.7.1. The Obsidian plugin pins its engine by release tag and SHA-256, so engine changes reach the editor only when the plugin is repinned. Check each consumer’s pin and generation before treating a toolchain change as an estate-wide deployment.
Version 0.6.0 adds an RDFS derivation certificate and consequence-delta support through the shared rdfs-certificate crate. The compiler checks the certified named subclass closure against its classifier output and refuses a mismatch. This is a derivation check under the implemented rules, not a proof of arbitrary OWL entailment or the truth of source assertions. certificate.rs and ADR-OM-009 define the boundary. An independent Lean checker is a separate tool; producing a certificate does not establish that it has been run.
This is experimental software. The reasoner implements a subset of OWL 2 EL and reports unsupported constructs explicitly; dropped existential restrictions make a classification incomplete (ADR-OM-004 records why EL, and how non-EL is named rather than dropped). The native publication compiler retains its legacy estate profile semantics while using the shared reasoner; typed in-memory projection is available through the compiler's model-projection feature.
Turtle, JSON-LD, SHACL, SKOS, PROV-O and Dublin Core form the publication surface. Public projections omit private content and sanitise links to private targets. Conformance and privacy tests record the supported behaviour; no claim of complete OWL 2 EL or universal standards conformance is made. The NGG1 graph format collapses named relations to one edge type; per-relation edges need a format bump.
- Current hand-off: verified results, outstanding work and integration boundaries.
- API documentation: crate contracts and capabilities.
- Decisions: ADR-OM-001 (profiles, licensing, reasoner), ADR-OM-002 (shared graph and plugin boundary), ADR-OM-003 (assisted ingest), ADR-OM-004 (OWL 2 EL), ADR-OM-005 (one producer, the generation loop), ADR-OM-006 (Dot Triples interop), ADR-OM-007 (flat vaults, the vault verbs), ADR-OM-008 (any Obsidian vault is a repository; layout and generation prefix from the profile), ADR-OM-009 (derivation certificates), and the estate ADR index.
- External review, 5 November 2026: each finding's verdict and outcome, the extraction benchmark results, and which release gates remain open.
- OntoCast triage: what the ingest design adapted from OntoCast and what it did not.
- Dot Triples bridge: one SPARQL CONSTRUCT that lifts Cristian Vasquez's dot-triples output into Ontomark's vocabulary, tested for parity with the engine.
- Upstream projects and third-party notices.
- Estate migration plan and branch recovery.
- Run log and evidence.
- Nightly dreaming: native contract evaluation in the estate's nightly cycle.
- The architecture is drawn, citation by citation, in the VisionFlow diagrams corpus under
docs/diagrams/ontomark/.
Maintained by John O'Hare and DreamLab AI.
MIT OR Apache-2.0. NOTICE records the rights holder's relicensing grant and exclusions. The reasoner preserves the Rust port's MIT notice and Scala Whelk's BSD-3-Clause notice; see its README.