Composable canvases
Map journeys, domains, and UX flows directly onto datoms. Layouts update the moment the stream changes.
Interface runtime
DaoFlow
DaoFlow rethinks how we approach graphics and computation. Instead of treating rendering, physics, UI, and dataflow as separate domains, DaoFlow unifies them under a single model: everything is a stream of datoms.
A stream is a continuous flow of datoms—tuples that represent state, transformation, or intent. Every pixel, vertex, shader parameter, and event is just another datom in motion. DaoFlow doesn't "run" code in the traditional sense; it interprets these streams, composing behavior and visuals from the same substrate.
At its foundation, DaoFlow is written in Rust for safety and performance. Its higher-level interface uses Yin-Yang, a Clojure dialect also implemented in Rust. Developers describe systems declaratively in Yin-Yang, while DaoFlow handles the orchestration of GPU and CPU workloads beneath the surface. Because the interpreter operates on streams, DaoFlow naturally supports reactive rendering, live state mutation, and distributed execution, all without separate paradigms for logic, data, and graphics.
DaoFlow is an interpreter of DaoStream datoms. To understand why interpretation creates meaning while structure alone cannot, read Structure vs Interpretation .
The Philosophy: Yin and Yang
Inspired by the Taoist concept of Yin and Yang, DaoFlow views computation not as discrete operations but as dynamic balance. Yin represents the generative, interpretive aspect, the flow of meaning, the why. Yang embodies execution, the form, the how. DaoFlow is the unifying principle between them, a bridge where interpretation and execution converge into one self-consistent stream.
The name Dao (道) reflects its guiding principle: harmony between opposites, the way that flows.
- Yin — interpretation, composition, generative flow
- Yang — execution, realization, hardware interaction
DaoFlow is the balance point, a system where meaning (Yin) and mechanism (Yang) cooperate through continuous feedback.
Stream-Based Rendering
Where traditional engines manage draw calls and frame loops, DaoFlow treats rendering as stream transformation. A 3D scene, a UI tree, or a compute graph are all the same: append new datoms, observe the flow, and let the GPU converge to the next visual state. This design makes it possible to prototype GPU pipelines, visualization tools, or even cross-platform frameworks (mobile, desktop, web) with the same reactive semantics.
Technically, DaoFlow is an interpreter of graphics primitives represented as datoms—small tuples describing state and transformation. Every vertex, texture, or shader is expressed as a datom flowing through the GPU pipeline. Instead of static render loops, DaoFlow treats rendering as a form of stream processing: scenes evolve, recompute, and re-render as the stream changes. This gives developers a consistent model for animation, simulation, and UI, all from a single, reactive substrate.
For Developers
For developers, this means fewer abstractions to fight. No more rigid boundaries between "engine" and "app." The same stream that drives your UI can drive your compute kernel or shader network. DaoFlow invites you to think in flows, not frames, to build systems that evolve naturally as data moves.
Live presentation semantics
Expose brand, motion, and interaction tokens as datoms so prototypes and production UI stay aligned.
Feedback in the flow
Annotations resolve back into the same stream, turning every review into structured memory DaoFlow can replay.
Because DaoFlow listens to the same streams your agents do, product surfaces never drift from the truth held inside your datoms.
DaoFlow isn't just another graphics runtime. It's an invitation to build software that feels alive, systems that compute the way nature flows.
Explore Yin to script stateful agents, or revisit Shibi to layer economic controls into your experiences.