Private preview

Share data without losing control

Data has to be shared to be useful, but once it is shared, control is easy to lose. Datom.World solves that tension with mobile continuations running inside the Yin.VM sandbox: execution stays local, explicit, and interpretable, while append-only streams of facts carry context to wherever work happens next.

Try the Live Demo

Memory Agents Can Share

For AI agents, the implications are concrete. Short-term context, durable history, and multiagent coordination all become queries over the same stream of facts, rather than hidden runtime state buried inside prompts or opaque caches. Nothing important is stuck inside a session.

DaoSpace extends that into collaboration. Multiple agents share an environment of datoms they can query and modify, so work is coordinated through explicit traces rather than accidental handoffs. Datom.World is therefore infrastructure for systems that need reliable shared facts, and for agents that need to remember, reason over history, and work together without losing causality.

Learn more: Containing Agent Smith in a Pocket Universe and Agent Smith as the Hippocampus .

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 do not 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 to 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 is not money and deliberately avoids being money-like. It is an anti-spam mechanism that keeps the network open without gatekeepers. Learn more about how Shibi works and why it cannot 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.

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.

Any software, whether it is 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. 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. 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.