Datom.World FAQ
What is Datom.World?
Datom.World is a new kind of internet — one built on collaboration, not control. Instead of routing your life through distant servers, it keeps information anchored to your devices and neighborhoods while still letting knowledge flow. Nodes share datoms—tiny structured facts—that stay private, portable, and ready to combine into living systems.
Why the metaphor of ant colonies and stigmergy?
Ants coordinate by leaving traces of chemical data for others to interpret, not by reporting to a central brain. Datom.World brings that principle online: every device leaves datoms in shared space, and the collective behavior emerges from local actions. It is self-organizing intelligence without command-and-control.
What does “everything is a stream” actually mean?
In Datom.World, data never freezes in silos. Every fact lives in an append-only stream that can be read, transformed, or extended. Streams become the common language for messages, automations, analytics, or agents— a single primitive that replaces piles of bespoke stacks. There's only two API: reaad and write
What does “everything is a continuation” mean for me?
Imagine pausing a story midway and later resuming at the exact sentence you left. A continuation is that bookmark—capturing where you are and what unfolds next. In Datom.World, every conversation, workflow, or shared process leaves such a bookmark so it can resume effortlessly.
- Your data, apps, and flows persist across time without depending on a single vendor’s session.
- Switching devices feels natural because your context lives in the shared world, not on one machine.
- Collaboration stays fluid—others can pick up where you paused, continuing the same thread securely.
Who owns the data flowing through these streams?
You do. Datoms stay under the author’s control from creation through sharing. There is no corporate datastore to monetize or subpoena. You decide which peers can observe a stream, for how long, and with which capabilities.
What is a datom, exactly?
A datom is the smallest unit of structured data: the immutable 5-tuple [entity attribute value time context]. It captures who, what, value, when, and provenance with enough structure to be recomposed safely. Just as atoms assemble into matter, datoms assemble into any data structure
How does this differ from conventional cloud computing?
Traditional clouds centralize data in opaque silos. Datom.World flips the model—data stays local, and streams entangle trusted devices with end-to-end encryption. You gain the convenience of synced collaboration without surrendering custody or observability.
What does collaboration look like without a central server?
Collaboration flows through entanglement: a lightweight protocol where independent nodes agree on the order of datoms. Leadership can rotate instantly, so the stream stays live even as devices appear or disappear. The result feels like a living network that adapts instead of waiting on a monolithic authority.
How is privacy preserved if everything is streaming?
Privacy is the default. Each datom can bundle access rules, key material, expiration, and audit trails. Encryption happens before transmission, so only the peers you authorize can interpret the facts they receive.
What kinds of experiences can I build?
Anything that benefits from shared truth: social spaces, marketplaces, automation meshes, IoT telemetry, multiplayer tooling, or AI agents. Because streams are universal, the same facts can render as dashboards, maps, spreadsheets, or code triggers— all without duplicating data.
What does Datom.World mean for the future of the web?
It aims toward a digital commons—where data lives with people, not platforms. Apps cooperate instead of compete, privacy and openness co-exist, and collective intelligence emerges from shared streams. Think of it as an internet reborn as an organism: decentralized, adaptive, and deeply human.
Developer deep cuts
Answering the technical questions builders ask first about the runtime, streams, and tooling.
What exactly is a datom in implementation terms?
A datom is a fixed five-element tuple: [e a v t c] → entity, attribute, value, time, context. It is immutable, append-only, and causally traceable. Datoms live locally, replicate by subscription, and form the atomic event log every index or materialization derives from.
How should developers interpret “everything is a stream”?
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.
What is entanglement between nodes?
Entanglement is a lightweight consensus mechanism. 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.
How is data stored and replicated?
Every node keeps an append-only tuple store and subscribes to streams it cares about. Replication pulls missing datoms, merges by timestamp or causal ID, and maintains local indexes. Compression, encryption, and snapshots are pluggable per stream.
How is privacy enforced in a decentralized fabric?
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.VM acting as the universal security container. Like Docker, WASM, or the JVM, Yin.VM 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 FAQ
Dive deeper into the universal continuation layer that powers Datom.World’s programmable computation.
What is Yin-Yang?
Yin-Yang is a universal continuation machine and compiler framework that unifies interpretation, compilation, and transformation.
It pairs Yin.VM—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.
Why is it called Yin-Yang?
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.
What is unique about Yin.VM?
- 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 EDN maps, never hidden behind bytecode.
- 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.
How does it differ from VMs like the JVM or EVM?
Where the JVM hides runtime state behind bytecode, Yin.VM exposes evaluation as data. Where the EVM prices computation but limits introspection, Yin.VM reifies continuations—enabling distributed execution, dynamic transformation, and zero-copy migration.
What is a map-based AST?
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.
What is the Yang compiler?
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.
What does “everything is a continuation” mean for developers?
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.
What does “everything is a continuation” mean for users?
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.
Can Yin.VM interoperate with other systems?
Yes. Yin.VM 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.
Why persistent data structures?
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.
What can developers build?
- Language interpreters and compilers.
- Distributed continuation services.
- Stream-based or reactive runtimes.
- Portable, inspectable computation graphs.
- Reflective or self-modifying research systems.
How does Yin-Yang relate to Datom.World?
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.
What is the long-term vision?
To reify computation as data so code, runtime, and transformation merge into one universal fabric—continuations flowing through datom streams.
Still curious?
Bring your scenario or data model and we will explore it together. Intros, architecture reviews, and partner pilots happen weekly.
Continuation mindset — the system never loses context.
- User perspective: the web remembers how it flows, so experiences remain seamless, local-first, and privacy-centric.
- Developer perspective: every execution state is a first-class continuation that unifies concurrency, recovery, and distribution.