{"id":25986814,"url":"https://github.com/computemachines/flowno","last_synced_at":"2026-04-16T23:04:07.406Z","repository":{"id":280485464,"uuid":"937754627","full_name":"computemachines/flowno","owner":"computemachines","description":"Python DSL for writing dataflow programs.","archived":false,"fork":false,"pushed_at":"2026-02-04T03:28:18.000Z","size":2475,"stargazers_count":0,"open_issues_count":14,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-02-04T14:54:04.444Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"https://flowno.net","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/computemachines.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null}},"created_at":"2025-02-23T20:16:46.000Z","updated_at":"2026-01-27T00:12:38.000Z","dependencies_parsed_at":null,"dependency_job_id":"0ba33a34-2e21-4244-8dd4-f6fc1852bf0a","html_url":"https://github.com/computemachines/flowno","commit_stats":null,"previous_names":["computemachines/flowno"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/computemachines/flowno","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/computemachines%2Fflowno","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/computemachines%2Fflowno/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/computemachines%2Fflowno/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/computemachines%2Fflowno/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/computemachines","download_url":"https://codeload.github.com/computemachines/flowno/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/computemachines%2Fflowno/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31907728,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-16T18:22:33.417Z","status":"ssl_error","status_checked_at":"2026-04-16T18:21:47.142Z","response_time":69,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2025-03-05T12:33:18.568Z","updated_at":"2026-04-16T23:04:07.393Z","avatar_url":"https://github.com/computemachines.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Flowno\n\nFlowno is a Python DSL for building concurrent, cyclic, and streaming\n[dataflow](https://en.wikipedia.org/wiki/Dataflow_programming) programs - ideal\nfor designing modular LLM agents. Inspired by no-code flowchart tools like\n[ComfyUI](https://github.com/comfyanonymous/ComfyUI), Flowno lets you describe\nworkflows in code while handling complex dependency resolution (including cycles\nand streaming) behind the scenes.\n\nBasically it is yet another attempt at implementing \"workflow\" style programming.\n\n## Key Features\n\n- **Node-Based Design**  \n  Define processing steps as nodes with a simple decorator. Nodes can be\n  stateless or stateful - consume, yield or transform streams - single or\n  multiple outputs. \n\n- **Cycles \u0026 Streaming**  \n  Unlike many workflow/flowchart/visual dataflow tools, Flowno supports cyclic\n  graphs and streaming edges. Use default values to bootstrap cycles.\n\n- **Concurrent By Default**  \n  The Flowno runtime schedules nodes to run as soon as their inputs are ready.\n  Flowno provides a set of basic non-blocking concurrency primitives.\n\n- **~~Type-Checked \u0026 Autocompleted~~**\n\n  TODO\n\n  ~~Flowno works well with type checkers and IDEs to catch incompatible~~\n  ~~connections between nodes.~~\n\n\n## Quickstart\n\nSet up a virtual environment and install Flowno:\n\n```bash\npython -m venv .venv  # Requires Python 3.10+\nsource .venv/bin/activate  # On Windows use: .venv\\Scripts\\activate\npip install flowno\n```\n\nCreate a minimal flow (`hello.py`):\n\n```python\nfrom flowno import node, FlowHDL\n\n@node\nasync def Add(x, y):\n    return x + y\n\n@node\nasync def Print(value):\n    print(f\"Value: {value}\")\n\nwith FlowHDL() as f:\n    f.sum = Add(1, 2)\n    f.print = Print(f.sum)\n\nf.run_until_complete()\n```\n```bash\n(.venv) $ python hello.py\nValue: 3\n```\n\n## How It Works\n\nFlowno has three key components that work together to create dataflow programs:\n\n### 1. Node Creation\nThe `@node` decorator transforms `async` functions (or classes) into a\nconstructor for a new subclass of `DraftNode`. The transformed function\ntakes takes connections to other nodes or constant values as arguments and\nreturns a `DraftNode` instance. \n\n```python\n@node\nasync def Add(x, y):\n    return x + y\n\ndraft_node_1 = Add(1, 2)  # Creates a node that will add 1 and 2\ndraft_node_2 = Add(draft_node_1, 3)  # Connects to the output of draft_node_1 to first input of draft_node_2\n```\n\n### 2. Flow Description\nThe `FlowHDL` context manager provides a declarative way to define node \nconnections. Inside this context, nodes are assigned as attributes and can reference \nother nodes' outputs:\n\n```python\nwith FlowHDL() as f:\n    f.node_a = Add(1, 2)          # No references\n    f.node_b = Add(f.node_a, 1)   # Backward reference\n\n    f.node_c = Add(f.node_d, 1)   # Forward reference\n    f.node_d = Add(f.node_c, 1)   # Backward reference creating a cycle\n```\n\nThe context uses Python's `__getattr__` method to return placeholder objects when \naccessing undefined attributes like `f.node_d`. These forward references are a core \nfeature of Flowno - they're not errors. However, each forward-referenced node must \neventually be defined in the flow (as shown in the last line for `f.node_d`). During \n`__exit__`, the placeholders are resolved into proper node connections, and all \n`DraftNode` instances are finalized into full `Node` objects.\n\nThis mechanism allows you to define nodes in any order, which simplifies the \nconstruction of cyclic graphs.\n\n### 3. Execution\nWhen you call `f.run_until_complete()`, Flowno executes your flow:\n\n1. Identifies nodes ready to run (those with all inputs available)\n2. Executes ready nodes concurrently\n3. Propagates outputs to dependent nodes\n4. For cyclic flows, uses default values to bootstrap the cycle\n\nThe runtime is asynchronous - nodes only wait for their direct dependencies and\nrun concurrently with other nodes.  Execution continues until all nodes complete\nor, for cyclic flows, until an uncaught exception occurs.\n\n## Features TODO\n\n- **Conditional Nodes**  \n  Currently all nodes are executed unconditionally. The only way to skip a node is to add an immediate return statement to bypass the node's logic. I plan to add a way to conditionally execute nodes based on the output of other nodes.\n\n## Non-Goals\n\n- **Visual Editor**  \n  Flowno is a DSL for defining dataflows in code. It does not include a visual\n  editor for creating flows. I have a crude prototype of a visual editor, but I\n  just don't see the value in dragging and dropping nodes. A visual editor can't\n  be used by a LLM agent, for example.\n\n- **Backpropagation**  \n  Flowno is not a machine learning framework. I considered adding some sort of\n  automatic differentiation, but I could never do it as well as PyTorch, and\n  cycles would be difficult.\n\n\n## About The Naming Conventions\n\n\u003e A Foolish Consistency is the Hobgoblin of Little Minds\n\u003e \n\u003e -- \u003ccite\u003eStyle Guide for Python Code (PEP-8)\u003c/cite\u003e\n\nMy naming conventions deviate from standard Python style. I capitalize node names \n(like `Add` instead of `add`) because they are factory functions that behave like \nclasses - when you call a decorated node function, it returns a `DraftNode` \ninstance.\n\nThe `FlowHDL` context with its `f.node_name = Node()` syntax is an abuse of \nPython's `__getattr__` method. However, this approach gets you:\n- LSP type checking support\n- Slightly better IDE autocomplete functionality\n- Forward references for natural cycle definitions\n\n## License\n\nFlowno is released under the MIT License.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcomputemachines%2Fflowno","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcomputemachines%2Fflowno","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcomputemachines%2Fflowno/lists"}