A datom is a fixed five-element tuple: [e a v t m] → entity, attribute, value, transaction ID (stream-local), metadata. It is immutable and causally traceable. Transaction IDs are monotonic within a stream but have no meaning across streams—cross-stream causality is established via metadata. Datoms flow through DaoStreams. Apps consume streams and can materialize datoms into indexes or other structures.

Streams are the single I/O abstraction. Read, write, transform, and entangle datoms through asynchronous channels instead of bespoke APIs. Files, sockets, message queues, and databases collapse into this one primitive, giving apps a shared protocol for collaboration.

Entanglement is a lightweight consensus mechanism. When streams entangle, one leader establishes event ordering, imposing a single monotonic sequence across the entangled streams. Entangled nodes maintain a partially ordered view of a shared stream. Temporary leaders serialize events, but leadership can shift on demand—delivering consistency without global locks or blockchains. Importantly, transaction IDs remain stream-scoped even when entangled—cross-stream causality is always determined via metadata.

Datoms flow through DaoStreams. Apps like DaoDB consume streams and materialize what they need. DaoDB maintains append-only indexes, merging datoms by timestamp and causal ID. Each node can choose what to materialize—some store everything, others keep only recent data or specific attributes.

Each datom includes metadata for access policies, encryption, and provenance. Nodes evaluate those rules locally before sharing, encrypt before transmission, and rely on short-lived capabilities—not central identity servers—to authorize peers.

Execution safety rides on Yin acting as the universal security container. Like Docker, WASM, or the JVM, Yin sandboxes code so untrusted continuations can run on your hardware without escaping. The same isolation reassures collaborators: their datoms can execute on your node without you peering into the VM, keeping both compute and data private even when hardware is shared.

Yin-Yang is a universal continuation machine and compiler framework that unifies interpretation, compilation, and transformation.

It pairs Yin—a continuation-centric virtual machine that evaluates map-based ASTs—with the Yang compiler that lowers higher-level languages into that canonical form. Together they make computation portable, inspectable, and transformable across networks.

Yin represents evaluation—the generative flow of continuations—while Yang embodies compilation—the structural organization of code. They continually transform into each other, forming two inseparable halves of a single process.

• Everything is a continuation: functions, closures, and coroutines live in the same model.
• Eval is the virtual machine: the evaluator is the runtime, not a separate layer.
• ASTs stay canonical as datoms, never disgarded after bytecode has been generated.
• Persistent CESK machine keeps control, environment, store, and continuation immutable yet efficient.
• Opcodes are configurable, so semantics and instruction sets can be tailored per deployment.

Where the JVM hides runtime state behind bytecode, Yin exposes evaluation as data. Where the EVM prices computation but limits introspection, Yin reifies continuations—enabling distributed execution, dynamic transformation, and zero-copy migration.

Programs are immutable maps with explicit keys for operation, arguments, environment, and continuation. Everything is addressable, inspectable, and serializable—ideal for distributed or persisted execution.

The Universal AST is a construction from datoms—not a separate representation. Programs are stored as datom streams, and the AST is materialized by querying those streams. This means your code is queryable data: you can search for all functions calling a specific API, trace dependencies, or transform programs using the same tools that query databases. This radical approach enables unprecedented capabilities for reflection, transformation, and AI-driven programming where code itself is a fluid, introspectable dataset. The datom is always the source of truth.

Yang lowers high-level languages (starting with Clojure) into Yin’s universal AST. Additional backends for Python, JavaScript, Rust, and beyond bring cross-language continuations into the same runtime.

Control flow, concurrency, and suspension points become data. You can capture, transform, serialize, or route continuations across the network—turning distributed computation into composable building blocks.

Programs can pause, migrate, or resume anywhere without losing context. Your computation travels with you—locally or in the cloud—with the same continuity as your data.

No—agents are continuations. In Yin, there is no distinction between an agent and a continuation. Every agent is a serializable execution state that can pause, migrate across devices, resume on different hardware, and maintain its full context. This unification means mobility, security, and computation merge into a single primitive.

Yes. Yin uses EDN as an interchange format so continuations cross language and network boundaries. It integrates with native Rust or C functions and can compile to or from platforms like Gambit Scheme or WebAssembly.

Persistent structures make it cheap to snapshot and resume whole VM states without mutation or leaks. You gain lightweight time travel debugging, safe distributed execution, and resilience without relying on stop-the-world garbage collection.

• Language interpreters and compilers.
• Distributed continuation services.
• Stream-based or reactive runtimes.
• Portable, inspectable computation graphs.
• Reflective or self-modifying research systems.

Datom.World handles data as streams. Yin-Yang handles computation as continuations. Together they form the continuation-aware fabric that powers programmable agents and attention economies.

To reify computation as data so code, runtime, and transformation merge into one universal fabric—continuations flowing through datom streams.