I built an open-source flow editor because every existing one is fundamentally broken

TL;DR: I spent years working with flow editors for chatbots, forms, and LLM orchestration. They all share the same broken architecture: nested menus, hidden logic, black-box nodes. So I built Wanderer – an open-source flow editor based on a new concept called Reactive Graph Sequencing, where the graph structure is the logic. No nested menus. No inline code. No configuration hell.

---

## The problem I kept running into

Every flow builder out there – Botpress, Voiceflow, n8n, you name it – follows the same pattern: drag a node, click on it, get buried in configuration. Need a condition? Another menu. API call? Another node, another config panel. Want to change something? Good luck finding where that logic actually lives.

I kept hitting this wall across different projects: chatbots, complex form flows, onboarding wizards, LLM orchestration. The tools all promise simplicity but deliver hidden complexity.

And here's the thing that really bugged me: no developer would accept this in a code editor. Imagine clicking a variable name and suddenly 10 nested submenus pop open. You'd close that editor instantly. But somehow we accept exactly this in flow builders.

## Why "better UI" isn't the fix

Most people blame the interface. "It just needs cleaner design. Fewer options." I don't think so. The UI is a symptom. The actual problem is the underlying architecture.

Think about it:

- An edge between two nodes already represents a condition ("if this, then that"). So why do flow builders bury another layer of conditions inside the nodes?

- Most builders love super-nodes – a "Choice Node" that contains the question, answer options, branching logic, and validation all packed into one. But those answer options are invisible to the graph structure. They're hidden inside a black box.

- Most flow builders are event-driven at their core. They have no real concept of state. So every edge case, every "what if the user goes back" scenario has to be manually wired inside nodes. The architecture can't handle it, so it dumps the complexity on you.

## What I built instead

I asked: what if the graph could hold the state itself?

The concept is called Reactive Graph Sequencing (RGS). The core idea:

- Every node knows if it's active or inactive

- Connections have clear semantic meaning – just three edge types: Must, May, Must Not

- These three types can express every logical gate visually: AND, OR, NOT, XOR

- When state changes, the graph re-sequences itself. No manual fallback paths, no inline conditions

Change a decision and entire branches die while others come alive. The structure is the logic.

And no, it doesn't get slower with complexity – it actually gets more efficient. The more branches exist, the more are "dead" at any given moment. Traversal shifts, it doesn't accumulate.

## The product: Wanderer

Wanderer is an open-source flow editor built on RGS.

- No nested menus

- No inline code

- No configuration hell

- The graph structure defines the logic

🔗 Website: wanderer-flow.de

🔗 Examples: wanderer-flow.de/flows

## Where I'm at

I'm currently focused on getting Wanderer in front of more people and gathering feedback. I've been building this mostly solo, and I'd love to hear from anyone who's struggled with flow builders before.

Has anyone else here hit the same wall with flow editors? And does the "graph = logic" approach make sense to you, or am I overthinking this?