Datom.world: A Moduli Space of Databases

Published Aug 14, 2026

A database is often defined by the shape it stores: rows, documents, triples, vectors, or graph edges. Datom.world starts one level lower. Values move through DaoStreams, and no stream element interprets itself. Meaning appears only when an interpreter observes the stream and decides what operations are valid.

The core axiom: interpretation is external to the stream. Semantics lives in the interpreter, not in the data.

Because interpretation is external, an interpreter can take arbitrary streams and materialize them as tuples, key/value entries, document trees, vectors, or graph projections: whatever data structure is fit for its operational context. Datom.world does not contain one inevitable database; it contains a space of possible database interpreters. Each coherent choice of observation semantics is one point in that space; the materialized structure follows from the observation rather than selecting the point.

The Mathematical Metaphor

The term moduli space is borrowed from algebraic geometry. In mathematics, a moduli space is a geometric space where each individual point represents a complex object (such as an elliptic curve or a manifold). Moving from one point to another corresponds to morphing the underlying object into a new shape.

Applying this metaphor to architecture fundamentally changes how we view databases. Historically, we treat relational, vector, and columnar databases as separate silos. The moduli space metaphor argues that the raw data is a shared, neutral substrate. The database is merely the lens (the interpreter) applied to that data. Therefore, DaoSpace (tuple matching) and DaoField (vector distance) are not layered on top of each other; they are sibling points in an open space of interpreters, projecting different algebraic rules over the exact same immutable byte stream.

What Defines a Point

A point in this moduli space is not selected by a file format or index layout. It is selected by restrictions on observation:

• What values count as admissible facts?
• How are facts matched, compared, or traversed?
• Which operations compose observations?
• What bounds make an observation immutable and repeatable?
• Which causal or historical rules does the interpreter impose?

Two systems may use identical storage and still occupy different points because their interpreters ask different questions. Two systems may use different physical indexes and still occupy the same point because their logical answers are identical.

DaoStream Is the Substrate

DaoStream is the abstraction boundary underneath every point. A stream may be local or remote, open or exact-bounded, carrying raw bytes, tuples, descriptors, indexes, programs, or any other payloads a consumer needs.

The stream supplies sequence and bounds, but it remains pure syntax. It never decrees whether a stream element is intrinsically a datom, graph edge, vector embedding, document, or database row. Interpreters take these streams and materialize them into whatever data structures and query capabilities fit their context.

This keeps the substrate stable while database paradigms evolve. A new database point can be introduced by publishing a new interpreter over existing streams rather than changing DaoStream or rewriting stored values.

DaoJing: Shared Storage Without Shared Semantics

DaoJing is an interpretation of DaoStream, but an intentionally restricted one. It observes an explicit pool of intake streams and materializes every opaque payload as a content-addressed key/value entry:

bytes = canonical-encode(x)
key   = content-hash(bytes)
KV[key] = x                 ; insert if absent

DaoJing interprets enough structure to canonically encode a value, derive its address, insert it idempotently, and retrieve it. It assigns content identity: the same content always resolves to the same address. It does not assign domain meaning.

DaoJing does not know whether x is a datom, B-tree node, positional index, indexed-snapshot manifest, vector embedding, graph projection, program, or image. Source-stream identity is operational cursor state and never becomes the stored value's semantic namespace.

DaoJing is a semantic-neutral KV materialization that any database point may use as storage.

DaoJing is therefore not another semantic point beside DaoSpace or DaoField. It is a reusable storage boundary beneath them. A point may use DaoJing, another content store, or no durable storage at all without changing its observation semantics.

DaoSpace: Exact Associative Matching

DaoSpace is the point selected by tuple-space semantics. Writers append immutable n-tuples generatively, naming no recipient. Readers find tuples associatively by describing their content.

match performs one exact positional template match. q generalizes matching into Datalog clauses joined through shared variables. Different tuple dimensions can meet in one query because unification depends on shared values rather than uniform width.

A canonical d5 datom interpreter may automatically build EAVT, AEVT, AVET, and VAET. Other tuple relations will one day explicitly request positional indexes of their own, a specified future extension. Both choices remain inside DaoSpace because indexes change access cost, not exact-unification semantics.

DaoField: Metric Observation

DaoField observes tuples through distance rather than exact equality. Its natural question is not, Which tuples unify with this pattern?, but, Which tuples are nearest under this metric?

DaoSpace and DaoField may observe the same underlying values and persist their derived structures in the same DaoJing. They remain different points because exact unification and metric proximity define different observation algebras.

Other Points

The same discipline admits other database points without forcing them into DaoSpace:

• a graph interpreter whose defining operation follows declared edges
• a document interpreter that projects and navigates nested entity views
• a columnar interpreter organized around vectorized operations over selected positions
• a temporal interpreter whose primitive observations are windows and causal relations
• a logic interpreter with a different inference or constraint regime

These examples become real points only when their operations and restrictions are explicit. Calling every derived map or traversal a new database would make the moduli-space claim empty. A new physical view is not enough. A distinct observation semantics is required. DaoSpace itself already projects entities through its pull verb, so a document interpreter counts as a different point only if navigating nested views, rather than associative matching, becomes its defining observation.

Indexes Are Coordinates, Not Ontology

Within any point, the same facts may be organized through several access paths. DaoSpace may have covered indexes or explicit positional indexes. DaoField may have approximate-nearest-neighbor structures. A graph interpreter may maintain adjacency projections.

These structures are coordinates chosen for efficient observation. They can be rebuilt, replaced, or persisted as indexed snapshots without changing the logical database point, provided they return the same answers under that point's semantics.

This distinction prevents optimization from becoming ontology. The interpreter defines truth. The index only helps the interpreter reach it faster.

No Universal Query Language

A moduli space of databases does not need one query language that pretends every observation is the same. Datalog is native to DaoSpace because it generalizes associative matching. Nearest-neighbor search is native to DaoField. Traversal is native where references define the observation.

Front ends may compile into several interpreters, and results may flow from one point into another through DaoStream. That composition does not erase their boundaries. Each interpreter remains explicit about the semantics it contributes.

Restrictions Give Each Point Shape

The moduli space is open, but each point must be restricted. DaoSpace requires exact positional rules. DaoField requires a declared metric. Without those restrictions, behavior becomes implicit and a database point loses its identity.

The substrate boundaries must be restricted too. DaoJing requires canonical content addressing and insert-if-absent materialization. That contract makes it dependable shared storage without turning it into a semantic database point.

This is how Datom.world remains extensible without becoming vague: the space of interpreters is open, while every admitted interpreter has a small, explicit contract.

The Larger Picture

Datom.world's database architecture is not one structure that understands everything. It is a composition of narrow interpreters over streams:

DaoStream (pure syntax) + content-addressed KV materialization             -> DaoJing storage
DaoStream (pure syntax) + generative writes, exact positional unification  -> DaoSpace (tuples & Datalog)
DaoStream (pure syntax) + metric proximity                                 -> DaoField (vectors & distances)
DaoStream (pure syntax) + another explicit observation                     -> another database point

The underlying streams can remain the same. The storage substrate can remain the same. What changes from point to point is the interpreter's defining observation, the data structures that observation makes worth materializing, and the questions it makes possible.

Datom.world is the moduli space. DaoSpace is the tuple-space point. DaoJing is semantic-neutral storage available to them all.

Learn more:

• DaoSpace Is a Tuple Space, Not a Moduli Space (the correction that locates DaoSpace precisely)
• Datalog on an n-tuple Tuple Space (why mixed-dimensional relations belong in DaoSpace)
• Structure vs Interpretation (why data does not carry its own meaning)