From Distributed Files to Semantic Streams: Evolving the Plan 9 Vision with Datom.world

Published Jan 15, 2026

In the pantheon of operating system design, Plan 9 from Bell Labs occupies a legendary space. It was the "pure" successor to Unix, designed by many of the same minds (Pike, Thompson, Ritchie) to address a world increasingly defined by networks. Plan 9's brilliance lay in its radical simplification: it took the Unix philosophy and pushed it to its absolute logical limit. For those unfamiliar with the system, Ken Thompson's talk and the original Designing Plan 9 paper provide excellent introductions to its design philosophy.

Decades later, the computing landscape has shifted again. We live in a world of omnipresent connectivity, massive data volumes, and functional, reactive programming paradigms. Datom.world is an architectural exploration that asks a critical question: What if we took the spirit of Plan 9, its commitment to universal abstractions and network transparency, but rebuilt its foundations using modern atomic units?

Datom.world does not clone Plan 9; it evolves it. It replaces the 1990s vision of a "distributed file system" with a 2030s vision of a "distributed reactive state machine."

Here is how Datom.world reinterprets the core principles of Plan 9 for a new era.

1. The Atomic Unit: From Bytes to Facts

The single most defining concept of Plan 9 is "Everything is a file." A mouse, a network connection, a window, and a process list are all exposed as file hierarchies reachable via a standard path. This was revolutionary because it meant a single set of tools (read, write, cat, grep) could manage the entire system.

However, a file is ultimately an unstructured stream of bytes. To derive meaning from it, the consumer must know the format specification: how to parse /dev/mouse versus /proc/123/status. Each resource type requires its own parser.

The Datom.world Evolution: "Everything is a stream of datoms."

Datom.world replaces the unstructured byte stream with a structured, semantic stream of Datoms. A datom is an immutable fact represented as a tuple: [Entity, Attribute, Value, Transaction, Meta].

• Plan 9: You read bytes from /dev/temp-sensor and must parse the ASCII string "25.5C".
• Datom.world: You subscribe to a stream and observe a fact: [:sensor-1, :temp/celsius, 25.5, T_100, M_auth].

The wire format still requires parsing, but the uniform structure eliminates format-specific parsers. The system moves from transporting opaque envelopes to transporting structured meaning.

Furthermore, Datom.world acknowledges the physical reality that machines only speak bytes. It implements a "Realization Spectrum." At the hardware level, a datom stream might be a highly optimized, fixed-width vector of bytes for zero-copy performance. A datom can even be encoded in a single byte on extremely constrained devices. But to the logic layer (like the yin.vm), it appears as a fully realized, high-level map. The system handles the translation seamlessly, grounding high-level abstractions in low-level efficiency.

2. Execution and State: From Processes to Continuations

Plan 9 was a pioneer in distributed computing. It allowed a user on a lightweight terminal to execute heavy processes on remote CPU servers transparently. The resources were distributed, but the process itself was still largely tied to a specific machine's kernel.

The Datom.world Evolution: "Everything is a continuation."

Datom.world takes the concept of "computing anywhere" to its logical extreme. It treats the entire state of execution: program counter, stack, registers, and logic, as a serializable data structure called a Continuation.

In Plan 9, you run a command over there. In Datom.world, the concept of "running" is fluid. A continuation is a portable object that flows across the datom fabric. If a server in Nha Trang becomes overloaded, a running continuation can be paused, serialized into datoms, moved to a server in Philadelphia, and resumed instantly. The "computer" is no longer a box; it is the network itself.

3. The Control Plane: From Text and Protocols to Pure Data

Plan 9 adhered to the principle that "Everything is Text." To dial a network connection, you wrote a text string like connect 1.2.3.4!80 into a control file. To facilitate this, Plan 9 relied on the 9P protocol, a stateful messaging system for filesystem operations.

Text is human-readable and debuggable, but requires parsing for machine processing. The 9P protocol, while elegantly simple, maintains session state.

The Datom.world Evolution: Protocol-less, Data-Driven Control.

In Datom.world, the datom is self-describing. The packet is the protocol. The [e,a,v,t,m] structure contains all necessary context: identity, attribute, value, causal order, and metadata (security/provenance). This trades 9P's stateful simplicity for stateless uniformity.

Consequently, the control plane is not text; "Everything is Datoms." Configuring the operating system is identical to inserting a record into a database. To change a system setting, you emit a datom: [:sys/config, :vm/max-memory, "16GB", T, M].

This turns the entire OS into a queryable, temporal database. You don't grep logs to find past configurations; you query the system history just as you would application data.

4. Composition: From Structural Union to Functional Pipelines

One of Plan 9's most powerful features was Union Directories. It allowed users to transparently stack directory hierarchies on top of each other. A user could overlay their private ~/bin directory on top of the system /bin to customize their environment. This was a structural, spatial composition of resources.

The Datom.world Evolution: Functional Interpreter Pipelines.

Datom.world reimagines composition through a functional lens. Instead of stacking static directories, it uses Interpreters to transform dynamic streams.

An interpreter is a function (itself a continuation) that subscribes to input streams and emits values to an output stream. To create a "union," you don't use a kernel mount; you use a Union Interpreter that merges two streams based on programmable logic (for example, prioritizing user config over system config).

This transforms the world from a static hierarchy of files into a reactive directed acyclic graph (DAG) of state. When a fact changes anywhere in the system, it ripples through the interpreter chains instantly.

5. The Missing Link: Discovery via "Scent"

Plan 9 relied on hierarchical naming and file servers for resource discovery. While these servers can be replicated, highly dynamic environments with mobile continuations benefit from more decentralized approaches.

The Datom.world Evolution: Stigmergic Discovery.

To support highly mobile continuations, Datom.world takes inspiration from nature. How do ants find resources without a central map? They use stigmergy: indirect coordination via pheromone trails in the environment.

Datom.world proposes a similar mechanism for stream discovery. Streams emit "scent datoms" that propagate through multiple physical channels, each serving a different architectural purpose:

The Five Senses of Discovery

Sense	Technology	Scope	Purpose
Sight	DNS / Seed Nodes	Global	Finding the "colony" from the open internet
Smell	Local Multicast	Subnet	Sensing service availability in the building
Hearing	Ultrasonic (Acoustic)	Room	Intentional discovery with someone next to you
Touch	BLE / NFC	Personal Space	Tethering your phone to your watch or laptop
Memory	Persistence (DaoDB)	Temporal	Recalling streams you interacted with previously

The Five Senses map discovery by scope; the ant metaphor maps discovery by intent. Ultrasonic requires physical proximity (you must be in the same room), making it ideal for intentional sharing. Sound doesn't travel through walls effectively, so receiving an ultrasonic datom is physical proof of presence.

The Bump Metaphor: Physical Intent

In the original Bump app, sound frequency served as a high-fidelity sync signal. In Datom.world, ultrasonic pings facilitate instant stream handshakes:

1. Acoustic Pairing: A phone emits an ultrasonic datom containing a temporary handshake scent: [:device, :scent/handshake, token-uuid, t, m]
2. Spatial Confirmation: Receiving that datom proves physical proximity (same room)
3. Stream Leap: Once confirmed acoustically, machines switch to high-speed byte streams over Wi-Fi or 5G to transfer the continuation

The Lifecycle of a Mobile Continuation

The ant metaphor fully realized:

1. The Journey: A continuation runs on your phone in Nha Trang, using DNS to maintain a heartbeat with your home server
2. Entering a Room: You walk into a workspace. Your phone "hears" an ultrasonic beacon from a shared monitor
3. The Scent: The beacon contains a scent for a :display/sink attribute
4. The Decision: The continuation decides this is a better output than the tiny phone screen
5. The Handshake: BLE (which also serves as a persistent tether) exchanges a gossip packet to verify credentials via m
6. The Flow: The continuation redirects its output stream to the monitor. Raw bytes flow over the local LAN

Plan 9's discovery was explicit and administrative: you had to know what you were looking for and where it lived. Datom.world's discovery is environmental and opportunistic. Resources constantly advertise their presence through multiple physical channels, and continuations constantly sense the best path to execute their logic. The system feels alive.

Conclusion

Plan 9 proved that a complex system could be built from a few profoundly simple abstractions. Its small codebase, text-based debuggability, and decades of proven reliability remain virtues that any successor must respect.

Datom.world honors that legacy by applying the same rigorous simplification to a new technological context. It trades Plan 9's kernel-level minimalism for interpreter-level flexibility, and text's universal debuggability for structured queryability. These are trade-offs, not pure wins.

By shifting the foundation from files to datoms, and from processes to continuations, Datom.world envisions a computing environment where the artificial boundaries between "database," "network," and "operating system" finally dissolve into a unified, semantic whole.