Quickstart

Install Bowire

Pick the package format for your platform. All five paths land at the same bowire CLI plus the embedded browser UI on port 5080.

winget install KuestenLogik.Bowire

brew tap kuestenlogik/bowire
brew install bowire

# Debian / Ubuntu / Mint
sudo apt install ./bowire_0.9.4_amd64.deb

# Fedora / RHEL / openSUSE
sudo dnf install ./bowire-0.9.4.x86_64.rpm

# Arch / Manjaro
yay -S bowire

# Or Linuxbrew (cross-distro)
brew tap kuestenlogik/bowire && brew install bowire

dotnet tool install -g Kuestenlogik.Bowire.Tool

docker pull ghcr.io/kuestenlogik/bowire:latest

docker run --rm -p 5080:5080 \
    -v ~/.bowire:/home/app/.bowire \
    ghcr.io/kuestenlogik/bowire:latest \
    --url https://api.example.com

Every package ships every first-party protocol plugin bundled (gRPC, REST, GraphQL, SignalR, WebSocket, SSE, MQTT, Socket.IO, OData, MCP). Sibling plugins (Storm, Kafka, DIS, UDP) install separately — see step 5.

Every install path on the downloads page → Configuration options (port, plugin dir, theme) →

Run it against your service

Point Bowire at any URL — your own ASP.NET app, a remote production service, an OpenAPI document on disk, anything.

bowire --url https://api.example.com

Multi-target works too — pass --url repeatedly to connect to several services in parallel:

bowire --url https://users.example.com:50051 \
        --url https://orders.example.com/openapi.json \
        --url https://chat.example.com/notifications

Bowire tries every installed protocol plugin against each URL and picks the one that responds. gRPC reflects, REST reads OpenAPI, GraphQL introspects, SignalR enumerates hubs, MQTT subscribes — all without configuration.

Open the workbench

Bowire opens a browser tab at http://localhost:5080/bowire (or whichever port you passed via --port).

The sidebar shows every service the plugins discovered, grouped by URL when you connected to several. Click any method, drop in inputs (typed form or raw JSON, toggle with f), hit Ctrl+Enter, response renders in the right pane. Streaming responses show as a Wireshark-style frame list, duplex protocols open persistent channels, and every call lands on the request history for replay.

Add the NuGet packages

Pick the protocol plugins your service speaks. The core Kuestenlogik.Bowire package is always there; protocols are opt-in so you only ship what you need.

dotnet add package Kuestenlogik.Bowire

# plus the protocols your service exposes
dotnet add package Kuestenlogik.Bowire.Protocol.Grpc
dotnet add package Kuestenlogik.Bowire.Protocol.Rest
dotnet add package Kuestenlogik.Bowire.Protocol.SignalR

Every first-party protocol (gRPC, REST, GraphQL, SignalR, WebSocket, SSE, MQTT, Socket.IO, OData, MCP) is its own package — same versioning, same release cadence. Sibling plugins (Storm, Kafka, DIS, UDP) follow the same pattern from their separate repositories.

Every package on the downloads page → Configuration options (mount path, theme, auth) →

Wire it into Program.cs

Two lines: AddBowire() registers the plugin host into DI, MapBowire() mounts the workbench at /bowire.

var builder = WebApplication.CreateBuilder(args);

// ... your existing service registrations ...

builder.Services.AddBowire();

var app = builder.Build();

// ... your existing middleware + routing ...

app.MapBowire();
app.Run();

That's the entire wire-in. Plugin discovery, protocol detection, and the browser UI all run in-process against the live IServiceProvider — no schema files, no parallel proto / OpenAPI to maintain, no second process to keep in sync.

Run your app

Start your service the way you always do, then open /bowire alongside your normal API routes.

dotnet run --project src/MyService

# → Listening on https://localhost:5001
# Open https://localhost:5001/bowire in your browser

Bowire picks up every protocol prerequisite for you: gRPC plugins call AddGrpcReflection() and MapGrpcReflectionService(), REST plugins read your IApiDescriptionGroupCollectionProvider, SignalR plugins enumerate mapped hubs via EndpointDataSource. Side effects scoped to dev / staging environments only — the production path stays untouched.