dfx is a Linux-only dynamic dataflow execution platform designed to construct, run, and manage directed graphs of computational nodes that exchange messages asynchronously.

It targets users who care about explicit dataflow, runtime reconfiguration, process-level control, and low-level system integration rather than monolithic pipelines or opaque schedulers.

The project is written in modern C++ and is built around Unix/Linux primitives (epoll, unix domain sockets, file descriptors, etc.). Windows is not a target.

What problem dfx solves

dfx is meant for scenarios where:

computation is naturally expressed as a graph of independent nodes
nodes communicate via typed message channels
the graph must be inspectable, controllable, and modifiable at runtime
execution scale across threads and CPU cores
tooling and observability matter as much as raw execution

Typical use cases include:

stream processing
event pipelines
message routing and transformation
simulation and orchestration
experimentation with dynamic execution models

Core concepts

At a high level, dfx is built around:

Nodes Independent computation units with named input and output ports.
Messages Typed payloads exchanged between nodes through channels.
Ports and Channels Directed connections defining how messages flow through the graph.
Graphs Directed dataflow graphs defined in .dfx configuration files.
Runtime control Graphs can be queried and modified while running via a Unix domain socket.

Execution is asynchronous and event-driven. Nodes do not assume a global clock or execution order.

Project layout and binaries

The dfx project is composed of four main binaries, each with a clearly defined role.

dfx - Dynamic Dataflow Executor

dfx is the core runtime executable.

It:

loads a dataflow graph from a .dfx configuration file
constructs and wires nodes and channels
executes the graph asynchronously
exposes a Unix domain socket for runtime inspection and control

Graphs can be modified at runtime without restarting the process or stopping the execution.

In short: dfx runs one dataflow graph.

dfxd - dfx Daemon and Instance Manager

dfxd is a long-running system daemon responsible for managing multiple dfx instances.

It:

spawns, monitors, and terminates dfx processes
provides a stable control endpoint via a Unix domain socket
centralizes lifecycle management

dfxd does not execute graphs itself - it orchestrates executors.

In short: dfxd manages many dfx instances.

dfx-ctl - Control and Inspection Tool

dfx-ctl is the command-line control tool for the dfx ecosystem.

It can:

control running dfx instances
interact with the dfxd daemon
query runtime state
send control commands
perform offline utilities (e.g. graph inspection and conversion)

Notably, it includes helpers such as:

converting JSON graph descriptions to DOT / image format
inspecting graph metadata without execution

In short: dfx-ctl is how users and scripts talk to dfx and dfxd.

dfx-gui - Graphical Interface

dfx-gui is the official graphical interface for the dfx platform.

It focuses on:

visually creating and editing dataflow graphs
defining nodes, ports, and connections
configuring graph scenarios
improving readability and correctness before execution

It complements the command-line tools by prioritizing usability and clarity, not runtime control.

In short: dfx-gui helps you design graphs; it does not replace the runtime tools.

Design philosophy

dfx follows a few strict principles:

Linux-first The project relies on Linux system interfaces and makes no attempt to be portable to Windows.
Explicit over implicit Graph structure, message flow, and control paths are visible and inspectable.
Runtime control matters Long-running systems must be observable and adjustable without restarts.
Tooling is part of the system CLI tools, daemons, and GUI are first-class citizens, not afterthoughts.
No magic schedulers Execution behavior is predictable and debuggable.

Documentation

This documentation (generated with Doxygen) covers:

core libraries and utilities
node and graph abstractions (soon)
runtime control interfaces (soon)
IPC and daemon architecture (soon)
helper utilities and formatting tools (soon)

Each binary and major component is documented separately.

License

dfx is released under the MIT License.

See the LICENSE file for full details.