ontos
ὄντοςOne vocabulary of being — here is a thing, and here is the kind of thing it is — said the same way everywhere.
what is — the shared vocabulary of values everything reasons over
https://github.com/Bitspark/ontos ↗Why it exists
More than one system needs to agree on what data is before it can do anything with it. A logic engine reasons over things; a fact substrate attests to them and chains authority through them; a store persists them. Each is a different account of meaning — but all are accounts of the same things. If every system invents its own notion of a value, every boundary between them becomes a translation, and translations drift, disagree, and leak.
ontos removes the seam. It is the one model they all share, so crossing from one system to another is not a conversion but an identity — the thing on this side is the thing on that side. It owns the value floor, and nothing more: it does not reason, persist, attest, or decide what is true.
A concrete example
ontos commits to exactly one kind of being. The value set V has two constructors: Atom(b), a leaf carrying a finite, uninterpreted byte string, and Tuple(v₀, …, vₙ₋₁), a finite ordered sequence of child values. That is all — no nil, no number, no string, no map at the floor.
Identity is structural and total. Atom(0x01) ≠ Atom(0x0001) (atom bytes differ by length), Tuple(a, b) ≠ Tuple(b, a) (order is part of the value), and Atom("") ≠ Tuple() — empty bytes and the empty tuple are distinct, and neither is "null." Richer data is not a special case bolted on below; it is named above. The integer 0 is the embedding int(Atom(0x00)) — a tuple whose first child is the label int, recognized by ontos/data, never by the floor.
What it unlocks
Because the floor distinguishes maximally and quotients never, a higher layer can always collapse distinctions it preserved, but can never recover one it erased. That asymmetry is what lets other systems build on ontos without redefining it. logos reasons over the same beings; thesmos, the law laid down, settles who may, and stele, the public record, attests them. Each does something different with one shared vocabulary. See where it sits in the stack.
What's next
The floor is frozen on purpose: ontos/core (L0), ontos/codec (ontos-codec-v1), ontos/compound (L1), and the ontos/data v1 embeddings are all marked frozen, with go, rs, and ts implementations replaying shared conformance vectors held byte-identical in CI. New capability is added above L0 — new data embeddings, new consumer layers — never to it.
Depends on
compiles or links against deixis
projection/deixis/rs rev-pins deixis-core and deixis-pos. CONFINED to that directory — core, codec and data have no deixis dependency — but projection/deixis/rs IS a default workspace member, so a plain `cargo build` at the root does resolve it. Consumers are unaffected: a git+tag dependency on ontos-core resolves that crate, not the workspace. The bridge is Rust-only and therefore UNWITNESSED under the ontos#191 maturity ladder; this edge states a build fact, not a parity claim.
Depended on by
the account is an ontos value with holes — Term mirrors ontos's Atom|Tuple, adding only Var
compiles against the ontos value model — ontos-core/ontos-codec git deps (tag v0.2.0), imports ontos_core::Value, ontos/core/go
compiles against the ontos value model — ontos-core/ontos-codec git deps (versions pinned per core; the per-core skew is intentional — see ADR 0010, byte-agreement enforced by vectors/, not version strings), go.mod require github.com/bitspark/ontos, imports ontos_core::Value
compiles against the ontos value model + the ontos-data embeddings, whose recognizers (int/utf8-text/bool/list/map/set) are horos's primitive type atoms; type-identity-critical (exactly one ontos must be linked)
the corpus fact codec builds on the ontos value carrier; intent — declared ahead of the codec landing
the value model + canonical codec kosmos speaks (direct go dep github.com/bitspark/ontos)
the Go backend compiles against the ontos value model (github.com/bitspark/ontos) — values, atoms, and the data embeddings the assertion vocabulary is built over
the value model + canonical codec — records and projected facts are ontos values; canonicalization delegates to ontos-codec (depend, never absorb)
the value model + canonical codec pharos reads off the record (direct go dep github.com/bitspark/ontos)
fact/value carrier compiled in — go dep github.com/bitspark/ontos v0.4.0
Examples involving ontos
A walkthrough of one participant becoming usable by another written years later, through substrate-visible evidence alone — and where that story is realized today versus still a sketch.
Docs exported by ontos
docs entry ↗docs/spec/ontos-core.md
docs/spec/ontos-codec.md
docs/spec/ontos-conformance.md