This is a community knowledge base for flow-based programming (FBP).
[Reading] | [Showcase] | [Reference] | [Community] | [Credits]
Flow-based programming on Wikipedia, Grokipedia, WikiWikiWeb, Python Wiki, and Tcl Wiki.
- J. Paul Morrison's Flow-Based Programming Website by @jpaulm
- Flow-Based Programming: Seminal Texts & Theoretical Foundations (2026) by @goodlux et al.
- Flow-Based Programming, a Way for AI and Humans to Develop Together (2023) by @bergie
- Flowmaps: Mapping Clojure core.async Flows Through Time & Space (2023) by @ryrobes
- The State of Flow-Based Programming (2022) by @trustmaster
- Tom Young's FBP Spreadsheet (2021) by @tyoung3
- What the Hell Is Flow-Based Programming? (2018) by @jm9e
| Project | Summary | Author | Language | License | Updated | Links |
|---|---|---|---|---|---|---|
| Apache NiFi | Mature ETL workflow system based on FBP. | @apache | Java | Apache | 2026 |  🏠 |
| Async-Flow | Async FBP core abstractions for Tokio. | @artob | Rust | Unlicense | 2026 | 📦 📖 🏠 |
| CppFBP | Classical FBP implementation for C++. | @jpaulm | C, C++ | Artistic | 2021 | |
| CsharpFBP | Classical FBP implementation for C#. | @jpaulm | C# | Artistic | 2021 | |
| Flowex | FBP/ROP framework based on GenStage. | @antonmi | Elixir | Apache | 2021 | 📦 📖 |
| Flows.rs | Reusable FBP building blocks for Tokio. | @artob | Rust | Unlicense | 2026 | 📦 📖 🏠 |
| GoFBP | Classical FBP implementation for Go. | @jpaulm | Go | Unknown | 2022 | |
| JavaFBP | Classical FBP implementation for Java. | @jpaulm | Java | LGPL | 2022 | |
| JSFBP | Classical FBP implementation for JavaScript. | @jpaulm | JavaScript | MIT | 2021 | |
| Node-RED | Popular low-code IDE for event-driven apps. | @knolleary | JavaScript | Apache | 2026 | 🏠 |
| NoFlo | Popular FBP-inspired runtime for Node.js. | @bergie | JavaScript | MIT | 2024 | 🏠 |
| Protoflow | Thread-based FBP using Protocol Buffers. | @artob | Rust | Unlicense | 2025 | 📦 📖 |
| RAMEN 🍜 | Lightweight actor-based message exchange library for embedded C++. | @Zubax | C++ | MIT | 2025 | |
| SciPipe | Mature scientific workflow library for Go. | @samuell | Go | MIT | 2024 | 🏠 |
This is a cross-reference for the widely varying nomenclature used in various FBP implementations. "Classical FBP" here means @jpaulm's nomenclature as found in his pioneering book and his open-source implementations (e.g., GoFBP, JavaFBP) that seeded the field.
| Classical FBP | Flux Theory | Apache NiFi | NoFlo | Node-RED | RAMEN |
|---|---|---|---|---|---|
| Network | System | Flow | Graph | Flow | Network |
| Subnet 1 | Subsystem | Process Group | Subgraph | Subflow | - |
| Component 2 | Block | Processor | Component | Node | Actor |
| Process 3 | Process | Processor | Process | Node | Actor |
| Connection 4 | Connection | Connection | Connection | Wire | Topic |
| Port | Port | Relationship | Port | Port | Event/Behavior |
| Information Packet (IP) | Message | Flow File | IP | Message | Message |
| Initial Information Packet (IIP) | Property | - | IIP | Config Node | - |
| Scheduler | Scheduler | Flow Controller | Runtime | Runtime | - |
A growing number of programming languages implement concurrency primitives suitable for building flow-based systems. Here follows a comparison of several widely-used languages:
| Clojure | Dart | Erlang | Golang | Python | Ruby | |
|---|---|---|---|---|---|---|
| Feature | core.async.flow | isolates | processes | goroutines, channels | asyncio | ractors |
| Since | 2025 | 1.0 | OTP | 1.0 | 3.5 | 4.0 |
| Runtime |
core.async.flow
|
dart:isolate
|
spawn
|
go, make(chan)
|
asyncio
|
Ractor
|
| Process |
(process)
|
Isolate
|
process | goroutine | coroutine |
Ractor
|
| Port |
(chan)
|
ReceivePort, SendPort
|
message queue |
chan
|
asyncio.Queue
|
Ractor::Port
|
| Message |
some?
|
Object?
|
any()
|
any
|
object
|
Object*
|
| Parallelism | thread-per-process | multi-core | multi-core | multi-core | single-threaded† | multi-core |
| Scheduling | OS / JVM | cooperative | preemptive | preemptive‡ | cooperative | OS threads |
| Isolation | shared (immutable) | fully isolated | fully isolated | shared memory | shared memory | shared (limited) |
| Backpressure | bounded | unbounded | unbounded | configurable | configurable | unbounded |
| Supervision |
:error-chan
|
addErrorListener
|
OTP supervisors |
recover
|
task exceptions |
Ractor#join
|
Parallelism describes whether the runtime can execute multiple processes
simultaneously on separate CPU cores. Erlang, Dart, Go, and Ruby all achieve
true multi-core parallelism. Clojure's core.async.flow runs each process on a
JVM thread (from configurable thread pools), also achieving multi-core
parallelism. Python's asyncio multiplexes coroutines on a single thread, so
it's concurrent but not parallel without reaching for multiprocessing.
Scheduling matters because it determines whether a long-running computation can starve other processes. Erlang is the gold standard here with reduction-counting preemption that guarantees fairness even for CPU-bound work. Go adopted signal-based preemption in 1.14 to prevent tight loops from hogging a core. Dart and Python are cooperative--a compute-bound isolate or coroutine must explicitly yield. Clojure and Ruby delegate to the OS/JVM thread scheduler.
Isolation has direct implications for data safety in FBP networks. Erlang and Dart processes have fully separate heaps and can only communicate by copying messages. Go and Python have shared memory, requiring discipline to avoid races. Clojure takes a middle path by encouraging immutable shared data. Ruby's ractors restrict sharing to frozen/shareable objects.
Backpressure determines whether a fast producer can overwhelm a slow consumer. Clojure's and Go's channels and Python's asyncio queues support bounded buffers that block senders when full--a natural fit for FBP. Erlang, Dart, and Ruby all have unbounded mailboxes/ports, meaning backpressure must be implemented at the application level.
Supervision captures how errors in one process are detected and handled by
the network. Erlang's OTP supervisor trees are the most mature model. Clojure's
core.async.flow centralizes errors onto a dedicated :error-chan. The others
offer varying levels of support through error listeners, panic recovery, or
exception propagation from tasks.
Here follows a small sample of the fine folks developing FBP frameworks and/or producing useful content about this approach to programming:
@antonmi, @apiri, @artob, @bergie, @exceptionfactory, @goodlux, @jm9e, @joewitt, @jpaulm, @knolleary, @markap14, @mcgilman, @pavel-kirienko, @ryrobes, @samuell, @statusfailed, @trustmaster, @tyoung3
👉 Join the FBP Slack! (Historically, there was also an active Flow Based Programming Google group but these days it's unmaintained and has been overrun by spam. Still, lots of useful information in the archives over there.)
Kudos to @samuell for putting together the first Awesome FBP list over at samuell/awesome-fbp.
