Private preview

Share data without losing control

Datom.World was envisioned around a simple tension: data has to be shared to be useful, but once it is shared, control is easy to lose. The answer is to keep the data local, explicit, and interpretable. DaoStream carries the live stream of facts and events, DaoDB materializes queryable views over those streams, and DaoSpace gives multiple agents a shared tuple space for collaboration.

Yin.VM continuations solve the same problem at the execution layer. A continuation is state you can pause, inspect, move, and resume without surrendering control of the computation itself. That is why the same design works for AI agents: short-term memory stays close to execution, long-term memory can be very large and remains accessible as streams via DaoStream, and multiagent collaboration happens through explicit shared facts instead of hidden internal state.

What is Datom.World?

Datom.World is a datom-native substrate for software that must remain sharable, inspectable, and under control. Instead of treating memory as a side effect of prompts, mutable objects, or hidden runtime caches, it represents state as immutable facts that can be streamed, persisted, queried, and shared. That keeps causality explicit, makes behavior replayable, and gives agents a memory model they can actually reason over.

The same design also solves the core AI-agent memory problem. Short-term memory has to stay close to execution so an agent can keep its current context and parked work. Long-term memory has to survive across sessions, devices, and interpreters. DaoStream carries the live agent stream, and DaoDB selectively materializes queryable views from that stream.

Multiagent collaboration has the same shape. Once more than one agent is involved, shared state cannot live only in chat transcripts or private model context windows. DaoSpace solves that by giving agents a shared environment of datoms they can query and modify. Agents coordinate by leaving explicit traces, so collaboration becomes a property of the data rather than an accident of messaging.

Datom.World is therefore not just local-first software. It is infrastructure for systems that need to share facts without surrendering control, and for agents that need to remember, reason over history, and work together without losing causality. That is why the platform is organized around DaoStream, DaoDB, DaoSpace, and Yin.VM continuations. Together they make memory, state, and collaboration first-class data.

The Core Concepts

Datom.World is built on four foundational principles that create a new paradigm for computing. These concepts are woven throughout our architecture, from the Yin VM to the DaoDB database. Each concept has links to more detailed articles for deeper exploration.

1. Everything is a Stream

The foundational axiom: everything is a stream . Streams transport whatever values each layer requires. Persistent facts are datoms: immutable facts represented as [e a v t m] (entity, attribute, value, transaction ID, metadata). Transaction IDs are monotonic within each stream; cross-stream causality is determined via metadata. Code, data, state changes, execution traces—all are append-only logs of datoms in the knowledge base.

Benefits: total auditability (nothing deleted, perfect history), time travel (query any past state), and a unified data model. Everything—messages, files, databases, APIs—collapses into a single primitive: the stream.

Learn more: Streaming Datoms with Transducers , AST as Higher Dimensional Datom Streams , and Code Entropy and Evolution (why distributing complexity to boundaries creates resilient systems).

2. Everything is a Continuation

If streams are how data flows, continuations are how computation flows. Every running process is a continuation : a serializable snapshot that can pause, migrate, and resume anywhere.

Built on Yin , your code becomes portable and secure. Start on your phone, continue on an edge server, finish on a GPU cluster. Enables true code mobility (Python to C++ with state intact), extreme fault tolerance, Airbnb-style compute (rent anyone's hardware with mutual security), and never losing context (resume on any device).

Learn more: Computation Moves, Data Stays .

3. Interpretation Creates Meaning

Meaning only emerges through interpretation . Data is just syntax; semantics are created when an interpreter observes and acts on it. This is the "one truth, many perspectives" principle: a single stream of datoms (one truth) can be interpreted differently by different observers (many perspectives), each extracting their own valid meaning.

This enables semantic evolution (new interpreters don't break old ones), multiple perspectives (different teams interpret the same stream differently), and AI collaboration (agents evolve their understanding without rigid schemas).

Learn more: Structure vs Interpretation .

4. The Universal AST is Canonical Code

The Universal Abstract Syntax Tree (AST) is the canonical representation of code . The text you see is just one rendering of this AST. Like Chinese characters providing a shared semantic layer for different dialects, the Universal AST enables bijective translation between languages (Python ↔ C++ with no meaning loss), syntax as preference (view/edit in your preferred language), and no parse errors (editing the structure itself).

Learn more: Yin.vm: Chinese Characters for Programming Languages and The Semantic Impedance Mismatch .

Keeping Open Networks Open

Open networks face an inevitable challenge: as they grow, spam threatens to make them unusable. Email proved this. The traditional solutions, centralized moderation or algorithmic filtering, either create gatekeepers or opacity.

Datom.World takes a different approach. Shibi is a capability-based economic layer that makes spam costly without requiring censorship. You issue your own purpose-specific tokens. To reach you or append to your streams, others need your tokens. You give them freely to trusted contacts, or set a price for strangers. Attention becomes a tradable asset you control, and spam gets priced out naturally.

Shibi isn't money and deliberately avoids being money-like. It's an anti-spam mechanism that keeps the network open without gatekeepers. Learn more about how Shibi works and why it can't be like money .

Recomposing the Web

Datom.World can be thought of as a decomposition of the modern web browser into its elemental technologies, then recomposed around a new philosophy to build a new world wide web: everything is a stream, and everything is a continuation.

In the traditional web stack, the JavaScript VM drives execution, HTTP defines communication, the DOM structures the UI, and local storage keeps data persistent. Each of these layers was built to serve a client–server world, where the browser is a consumer of remote computation. Datom.World reverses this assumption. Every device, from a phone to a cluster, becomes a sovereign node capable of computation, storage, and visualization.

Where the JavaScript VM once stood, Datom.World introduces Yin , a continuation-based virtual machine that treats computation as an evolving process rather than a sequence of calls. HTTP's request–response model dissolves into DaoStream , the universal streaming API where data flows continuously between entangled peers through append-only datom streams. LocalStorage becomes DaoDB , an app that materializes queryable indexes from those streams. The shared coordination space becomes DaoSpace , a tuple space implementation that enables stigmergic coordination between agents via Datalog queries over shared streams. And instead of the DOM, DaoFlow interprets streams as renderable interfaces, treating the UI as an emergent view of living data.

Each component corresponds to its web counterpart, but their composition is entirely different. Instead of a client viewing a remote world, every node in Datom.World participates in creating that world. The result is not a web of documents or servers, but a web of processes, a distributed organism of computation and collaboration.

In short, Datom.World is what the Web becomes when it is rebuilt from first principles: local-first, continuation-based, and stream-native. Where the old web is limited to HTML, Datom.World interpreters can visualize the same datom streams as anything: 3D video games, traditional web pages, VR environments, or any other form. DaoFlow is one such interpreter that renders datoms into living, reactive interfaces.

And the same recomposition applies beyond browsing. Compilers and languages themselves are being rebuilt as queryable datom fabrics: Yin.vm expresses programs as Datalog facts, DaoDB turns optimizations into queries, and DaoStream carries execution as continuations. Recomposing the web therefore also means recomposing the tools that build it.

The same decomposition can even be recomposed into a single address space operating system. As described in The Tao Kernel , discarding the legacy abstractions of virtual memory and context switching in favor of stream interpretation and first-class continuations allows the OS to operate as a unified semantic heap, where security is enforced by fine-grained capabilities rather than hardware rings.

This is not just the internet reimagined; it is software reimagined. Any software, whether it's an operating system,a compiler, a database, a GPU calculation, a 3D game, or an AI agent, fundamentally boils down to writing interpreters of datom streams. Instead of siloed applications managing private state, we build interpreters that observe, transform, and visualize shared streams. This unifies the entire stack into a single, cohesive fabric where data flows through time, continuations flow through space, and intelligence emerges from the network itself.