The open specification for executable event-driven flows.

Nodes define business logic. Edges define delivery semantics. The runtime enforces guarantees.

Each specification describes a different layer of your system. FlowDSL completes the picture:

FlowDSL is fully self-contained. Events and packets are defined natively in components.events and components.packets. OpenAPI and AsyncAPI are optional integrations — your FlowDSL documents work without them.

A complete LLM email triage pipeline — classified, routed, and delivered with the right guarantees at each step:

flowdsl: "1.0.0"
info:
  title: Smart Email Triage
  version: "1.0.0"

flows:
  email_triage:
    nodes:
      email_fetcher:   { $ref: "#/components/nodes/EmailFetcherNode" }
      llm_classifier:  { $ref: "#/components/nodes/LlmClassifierNode" }
      intent_router:   { $ref: "#/components/nodes/IntentRouterNode" }
      email_sender:    { $ref: "#/components/nodes/EmailSenderNode" }
      slack_notifier:  { $ref: "#/components/nodes/SlackNotifierNode" }
    edges:
      - from: email_fetcher
        to: llm_classifier
        packet: "#/components/packets/IncomingEmail"
        delivery:
          mode: direct                # in-process, zero overhead

      - from: intent_router
        to: email_sender
        when: "output.category == 'support' || output.category == 'inquiry'"
        delivery:
          mode: durable          # business-critical — persisted to MongoDB
          store: mongo
          retryPolicy:
            $ref: "#/components/policies/emailRetry"

      - from: intent_router
        to: slack_notifier
        when: "output.priority == 'high'"
        delivery:
          mode: ephemeral        # burst smoothing via Redis
          backend: redis

components:
  events:
    EmailReceived:
      summary: A new email has been fetched from the inbox
      version: "1.0.0"
      entityType: email
      action: received
      payload: { $ref: "#/components/packets/IncomingEmail" }

The JSON document is always the source of truth — not the canvas, not the runtime config.

Stop hardcoding Kafka everywhere. Each edge in your flow declares exactly the delivery guarantee it needs:

Every node in the registry has a semantic kind — the runtime uses it for scheduling, Studio uses it for color-coding:

Nodes can be written in Go, Python, or TypeScript. Cross-language invocation uses gRPC + Protobuf — no HTTP between nodes, no serialization overhead.

FlowDSL Runtime (Go)
  │
  ├── Go nodes      ── in-process (direct function call, zero overhead)
  ├── Python nodes  ── gRPC → flowdsl-nodes-py:50052
  └── JS/TS nodes   ── gRPC → flowdsl-nodes-js:50053

Every node implements the same NodeService interface — defined once in schemas/node.proto, consumed by all three language SDKs.

Pre-built nodes are published at repo.flowdsl.com — the open registry for FlowDSL nodes.

{
  "id": "flowdsl/llm-analyzer",
  "kind": "llm",
  "language": "python",
  "runtime": {
    "invocation": "grpc",
    "grpc": { "port": 50052, "streaming": true }
  },
  "settingsSchema": {
    "properties": {
      "prompt":        { "type": "string" },
      "model":         { "enum": ["claude-sonnet-4-5", "gpt-4o", "gemini-1.5-pro"] },
      "outputFormat":  { "enum": ["text", "json"] }
    }
  }
}

Drag a node from the Studio catalog → fill in settings → connect edges. No boilerplate. No transport code.

# Validate an example against the schema
git clone https://github.com/flowdsl/spec
cd spec
npm install -g ajv-cli
ajv validate -s schemas/flowdsl.schema.json -d examples/email-triage.flowdsl.json

# Or clone the examples repo and spin up infrastructure
git clone https://github.com/flowdsl/examples
cd examples
make up-infra          # MongoDB · Redis · Kafka · ClickHouse
open http://localhost:5173   # FlowDSL Studio

Full tutorial → flowdsl.com/docs/getting-started

FlowDSL docs ship with:

• /llms.txt and /llms-full.txt for LLM consumption
• Native MCP server at https://flowdsl.com/mcp

Connect your IDE to the FlowDSL knowledge base:

# Claude Code
claude mcp add --transport http flowdsl https://flowdsl.com/mcp

# Cursor — .cursor/mcp.json
{ "mcpServers": { "flowdsl": { "type": "http", "url": "https://flowdsl.com/mcp" } } }

FlowDSL is Apache 2.0. The commercial products build on top:

Contributions are welcome across all repos. The best place to start is the spec:

git clone https://github.com/flowdsl/spec
cd spec

# Add a node manifest, write an example flow, improve the schema
# Then validate:
ajv validate -s schemas/flowdsl.schema.json -d examples/your-flow.flowdsl.json

→ CONTRIBUTING.md → Good first issues → Discord