local message lab
github # get started

Feed your broker.
Test your app.
Skip the scripts.

Devset is a small, local-first app for testing message-driven systems on Kafka and RabbitMQ. Built for engineers who want a real UI — and for everyone on the team who shouldn't have to write a script just to fire one message.

$ docker compose up see how it works →
  • kafka & rabbitmq from one shell
  • visual flow builder, not yaml
  • nothing leaves your machine
  • built for devs and non-devs alike
  • ⊙ Message Dispatch fire real messages with payload & headers
  • ⌬ Flow Builder drag stages, wire repeats, emits, conditions
  • ƒ Function Studio shape payloads field-by-field, no JSON pain
  • ≡ Workflow Runs live event stream, replay, status
  • ▤ Schema Repo JSON Schema & Protobuf, versioned
  • ▷ Playground dry-run flows, no broker required
install

install

Run Devset locally in seconds with Docker.

Devset ships as a prebuilt Docker image. Pull it, point it at your local Kafka or RabbitMQ and start testing. Frontend and backend run together out of the box.

step 01

Pull

docker pull ghcr.io/devset-io/devset-ce:latest
step 02

Run

docker run -p 8082:8082 -v devset-data:/data ghcr.io/devset-io/devset-ce:latest
step 03

Open

http://localhost:8082

Make sure your local broker (Kafka or RabbitMQ) is running. Then configure the connection in Settings → Brokers inside the UI.

visual flow

visual flow

Build flows on a canvas, watch them execute as a visible chain.

The Flow Builder uses a node-based canvas where you drag stages, connect them visually and configure each step inline. Then fire the flow and trace every message from source event to delivery outcome — no scripts, no guessing.

flow builder ▸ shop-purchase-flow canvas · 4 stages · dsl auto
Add To Cart START #1

add-to-cart

repeat x1emit on
Checkout #2

checkout

repeat x1emit on
Payment #3

payment

repeat x1emit on
Confirmation END #4

confirmation

repeat x1emit on
start/end computed from position dsl payload built from nodes schemas 10 loaded from api
canvas editor

Drag, connect, configure — then run.

Each stage is a node. Click it to edit headers, payload and Function Studio logic. Wire stages together to define order. Set repeats, emits and conditions per stage. Run the whole flow from the same view.

drag & dropstagesconditionsrepeatsemitsdsl preview
data sources

Real data, not fixtures.

Before a stage emits, it can query your database and inject results into workflow.state. Test with live rows — not hardcoded JSON you copy-pasted three months ago.

db queryworkflow.stateper-stage

Why a canvas

Multi-step event flows are hard to reason about in raw JSON or YAML. The canvas gives a spatial view of the whole pipeline — you spot gaps before you run.

// example journey · 4 stages · real payloads
Open Page

User opens the storefront and starts a new local session.

{
  "header": {
    "eventName": "PAGE_OPENED",
    "eventType": "user.page.opened",
    "journeyStep": "1"
  },
  "payload": {
    "sessionId": "cc6e6471-...",
    "userId": 370282,
    "page": "home"
  }
}
Click Product

The same user clicks into a product and enriches the payload.

{
  "header": {
    "eventName": "PRODUCT_CLICKED",
    "eventType": "user.product.clicked",
    "journeyStep": "2"
  },
  "payload": {
    "sessionId": "cc6e6471-...",
    "productId": 5417,
    "productName": "Sneakers X",
    "category": "shoes"
  }
}
Add To Cart

Cart data appears in the next event without losing previous context.

{
  "header": {
    "eventName": "ADDED_TO_CART",
    "eventType": "user.cart.item.added",
    "journeyStep": "3"
  },
  "payload": {
    "cartId": "4d20f07c-...",
    "productId": 5417,
    "quantity": 1,
    "cartValue": 233
  }
}
Pay & Create Order

The journey ends with a paid order event ready for consumer verification.

{
  "header": {
    "eventName": "ORDER_CREATED",
    "eventType": "user.order.created",
    "journeyStep": "4"
  },
  "payload": {
    "orderId": "f82add80-...",
    "paymentStatus": "PAID",
    "paymentMethod": "CARD",
    "orderStatus": "CREATED"
  }
}
function studio

function studio

Build payload DSL visually, field by field.

Function Studio is built into the Flow Builder and Message Dispatch. Instead of writing raw JSON, you define field-level transformations with a visual editor — set literal values, reference other fields, add conditions or generate dynamic data per field.

local-first

local-first

Your payloads, headers and workflows stay on your machine.

Devset connects directly to your local broker. No cloud relay, no hosted middleman. Every workflow run, every message, every schema lives in your environment. You see the full execution path — no hidden automation.

roadmap

roadmap

What exists now, what is next, what the community can shape.

A visible roadmap makes the project easier to trust and easier to contribute to.

now · shipped

Already in core

  • dispatch real Kafka and RabbitMQ messages with headers, payloads and local broker targets
  • build multi-step flows with Function Studio, repeats, emits and stage logic
  • inspect workflow runs, schemas and broker settings in one UI
q3 2026

Next up

  • more advanced flow building with branching paths and multi-step journeys
  • pull data from APIs and databases directly into flow execution
  • state control across stages so one flow can drive multiple paths
planned

Longer horizon

  • team schema library — share event contracts across the team
  • shared flow history — replay and compare runs together
  • role-based broker access
faq

faq

Questions developers tend to ask first.

Can I use Devset for both Kafka and RabbitMQ flows?

Yes. The product story is written around Kafka and RabbitMQ rather than one broker only.

Does any message data have to leave my machine?

No. Devset connects directly to your local broker. Nothing is relayed through external servers.

Can I start without Docker?

Devset runs in Docker. Point it at your existing local Kafka or RabbitMQ — no extra containers beyond the app itself.

Is the Community Edition the full product?

Yes. All core modules — dispatch, flow builder, function studio, schema repo — are included in the CE without a paid tier.

What license does Devset use?

FSL-1.1-Apache-2.0 (Functional Source License). You can read, modify and run the code freely. You cannot use it to build a competing commercial product. Two years after each release, that version converts to Apache 2.0.

Will Devset always be free to use?

Yes for developers. Devset is free for internal use, testing and development. The FSL restriction only blocks third parties from reselling Devset as a competing commercial product.

Do I need to write any code to start testing?

No. Compose payloads in the UI, configure field logic in Function Studio and fire messages without writing test scripts.

Where do I report bugs or ask for features?

Open an issue on GitHub. PRs welcome too — the project is source-available.

get started

Stop pasting JSON into terminals.

Connect Devset to local Kafka or RabbitMQ and send your first real message in under 2 minutes. No scripts. No cloud.

open github → install in 3 steps