v0.0.17

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component files and resiliency policies. v0.0.17 cleans up the app list as your dev session evolves — a new Clear inactive control and per-app Remove for fully-stopped apps — and expands the in-app Dapr CLI command drawer across more pages.

What's new

🧹 Clear inactive apps

• A global Clear inactive button on the Applications page removes every fully-stopped app from the list in one click, so what you see stays in sync with what's actually running.
• Each stopped app row also gets its own Remove action for one-at-a-time cleanup, and fully-stopped Docker Compose apps can now be removed straight from the App detail page.
• Removal is non-destructive: it suppresses the app from the live view via the lifecycle overlay rather than touching your processes or containers. If a suppressed app starts running again, it reappears.

⌨️ More Dapr CLI commands in the drawer

• The context-sensitive Dapr CLI drawer gains additional commands across the Applications, Control plane, Subscriptions, Workflows, Workflow detail, Actors, and App detail views — more copy-ready commands for the page you're on.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

Go (≥ 1.26):

go install github.com/diagridio/dev-dashboard@v0.0.17

go install names the binary after the module path, so it produces dev-dashboard, not diagrid-dev-dashboard — rename it afterwards or use the install script above.

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.17

Run:

diagrid-dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. This release's tag commit ships the prebuilt UI so go install works without a frontend build step. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.16

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component files and resiliency policies. v0.0.16 sharpens two everyday flows: the Logs page filters collapse from three dropdowns to a single Target picker plus a compact daprd/app toggle, and the Restart & Start controls are now scoped to the apps where they actually work.

What's new

🔎 Simpler Logs filtering

• The App and Control plane pickers — which were always mutually exclusive — are now one grouped Target dropdown (Applications / Control plane), so choosing what to tail is a single decision.
• The daprd + app / daprd only / app only Source dropdown is replaced by a compact daprd | app toggle that appears only when you're viewing an app. Both lit means combined; you can't turn both off.
• Every existing deep link (from an app, from the control-plane page) keeps working unchanged.

▶️ Restart & Start scoped to Docker Compose apps

• Restart and Start now appear only for Docker Compose apps, where the container runtime restarts them cleanly. This removes buttons that set a false expectation elsewhere.
• For dapr run (standalone) apps only Stop is offered, with a hint to restart from your terminal; a stopped standalone app still offers Remove from list so the flow never dead-ends. Aspire and testcontainers apps are unchanged.
• The backend rejects start/restart for non-Compose apps with a clear error instead of an unreliable process-snapshot replay.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

Go (≥ 1.26):

go install github.com/diagridio/dev-dashboard@v0.0.16

go install names the binary after the module path, so it produces dev-dashboard, not diagrid-dev-dashboard — rename it afterwards or use the install script above.

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.16

Run:

diagrid-dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. This release's tag commit ships the prebuilt UI so go install works without a frontend build step. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.15

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component files and resiliency policies. v0.0.15 turns the read-only Subscriptions page into an interactive dev tool — publish test messages straight to a topic — and can now be installed with go install.

What's new

📨 Publish test messages from the Subscriptions page

• Each subscription row now has a Publish button that opens a dialog to send a real message to the topic through the app's own sidecar. Edit the JSON (or text) payload, choose a content-type, and optionally set ttlInSeconds or rawPayload under Advanced.
• On success you get a direct link to the app's logs to watch the message get handled; daprd errors (unknown pub/sub component, empty topic, …) are surfaced inline. The button is disabled when the app's sidecar isn't reachable.

🔎 Richer subscription insights

• Added a Type column (declarative vs programmatic) and dropped the always-empty Scopes column.
• Multi-rule subscriptions now expand inline to show each routing rule's match expression → path.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

Go (≥ 1.26):

go install github.com/diagridio/dev-dashboard@v0.0.15

go install names the binary after the module path, so it produces dev-dashboard, not diagrid-dev-dashboard — rename it afterwards or use the install script above.

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.15

Run:

diagrid-dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. This release's tag commit ships the prebuilt UI so go install works without a frontend build step. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.14

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component files and resiliency policies. v0.0.14 adds two developer-facing features: a context-sensitive Dapr CLI command drawer and a one-click Share dialog.

What's new

⌨️ Context-sensitive Dapr CLI drawer

• A new collapsible Dapr CLI drawer slides in from the right edge and surfaces the Dapr CLI commands relevant to the page you're on — dapr list on the apps overview, dapr stop --app-id <id> on an app's detail page, dapr workflow list / history / suspend / resume / terminate / purge on the workflow views, dapr scheduler commands on actors, and dapr publish on subscriptions.
• App IDs and workflow instance IDs from the current view are filled into the commands for you, and every command has its own copy button. Commands are self-hosted only (no Kubernetes -k variants), and the drawer's content lives in editable files so it's easy to extend.

📤 Share the dashboard

• A Share button in the top navigation opens a dialog to send the dashboard to a colleague — copy the ready-made message, or post it to Email, X, LinkedIn, or BlueSky with the text prefilled.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.14

Run:

diagrid-dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.13

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component files and resiliency policies. v0.0.13 is a focused release: a state-store discovery fix and a change that makes go install work out of the box.

What's new

🐛 State-store election no longer defaults to dead stores

• A stopped app could keep providing the "active" state store — a dead compose project (e.g. postgres, actorStateStore) would win election over a running Aspire app's own store, and once a running app's store was dismissed it could never reappear. The result: the workflow view defaulted to a dead store and the running app's store went missing from the panel.
• Election now counts only running apps, while stopped stores stay detectable and listable. Flipping an app from running to stopped re-triggers reconciliation and re-election, and every store a running app provides is un-dismissed — not just the elected one.

📦 go install now works out of the box

• The built React SPA (web/dist) is committed so the go:embed step no longer needs a separate frontend build. You can now install straight from source:

  go install github.com/diagridio/dev-dashboard@v0.0.13

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.13

Run:

diagrid-dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.12

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component files and resiliency policies. v0.0.12 is a small but important release with one headline change: the dashboard binary has a new name.

⚠️ Breaking: the binary is now diagrid-dev-dashboard

The CLI, release archives, and installed binary are renamed from dev-dashboard
to diagrid-dev-dashboard. Existing installs cannot self-update across this
rename — dev-dashboard update (and the startup update prompt) will fail with
"release not found". Reinstall once with the one-liner:

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

then delete the old dev-dashboard binary (the installer prints its location if
one is found). The GitHub repo, Go module path, container image names
(ghcr.io/diagridio/dev-dashboard), DEVDASHBOARD_* environment variables,
and your saved state-store connections in ~/.dapr/dev-dashboard/ are unchanged.

What's new

🏷️ The rename, end to end

• Every layer moves together: release archives are now diagrid-dev-dashboard_{version}_{os}_{arch}.* with a diagrid-dev-dashboard binary inside, the CLI help and --version banner carry the new name, and the self-updater expects the new naming — so upgrades from this version onward work seamlessly again.
• The install scripts install to the new name and print a notice when they find an old dev-dashboard install, so you know exactly what to remove.

📚 Docs & housekeeping

• The README got a restructure, and all docs (README, ARCHITECTURE, contributor docs, issue template) consistently use the new binary name.
• CI now skips docs-only and tooling-only changes via a shared paths allowlist.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.12

Run:

diagrid-dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.11

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component and resiliency YAML. Where v0.0.10 turned the dashboard toward the integration-testing workflow (Testcontainers discovery, sidecar workflows, MongoDB), v0.0.11 is about focus: a new set of exclusive --mode filters lets you point the dashboard at exactly one way of running Dapr — dapr run, Docker Compose, Testcontainers, or .NET Aspire — and every view follows.

What's new

🎛️ Exclusive --mode discovery filters

• --mode dapr-run, --mode compose, --mode test-containers, and --mode aspire (also via DEVDASHBOARD_MODE) each restrict discovery to a single source — filters are exclusive and never combined. Leave the mode unset and the dashboard performs the complete scan across all sources, exactly as before.
• The filter applies to every surface: applications, workflows, state-store detection, the Control Plane view, and the Logs page's target list all follow the selected source.
• compose and test-containers require a container runtime and now fail fast at startup with a clear message when docker/podman is missing — no more silently empty dashboard.

🐝 Aspire mode on the host

• --mode aspire gains a second life outside the AppHost: run the dashboard as a standalone host process and it filters the local process scan down to Aspire-managed apps (detected via the Aspire DCP proxy). Inside an AppHost-managed container (the DEVDASHBOARD_APP_* contract), everything behaves exactly as in v0.0.9.

🎚️ Mode-aware Control Plane & Logs

• The Control Plane view shows only the family that matches your mode — the dapr init containers for dapr-run/aspire, compose-run placement/scheduler for compose — and its start/stop/restart and log-stream actions are gated the same way.
• Empty states now tell the truth per mode instead of always suggesting dapr init, and the Logs page no longer offers dapr_* log targets in modes where they don't apply.
• Bonus fix: with no control-plane services enabled, the dashboard no longer runs a bare docker stats that sampled every container on the machine each poll.

🏷️ "Mode" column

• The Applications table's Run template column is now Mode, showing where each app came from with friendly names — Dapr run, Compose, TestContainers, Aspire — and the run-template name preserved as a tooltip. App detail gains a matching Mode row.

📚 Docs

• The README documents the new mode switch, and ARCHITECTURE.md now covers the mode-driven source selection and the capabilities layer (how one binary serves host and container postures with different feature sets).
• go install builds now embed the pre-built SPA, so the binary works out of the box without a local frontend build.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

With Go (≥ 1.26):

go install github.com/diagridio/dev-dashboard@v0.0.11

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.11

Run:

dev-dashboard                        # complete scan, http://localhost:9090
dev-dashboard --mode compose         # only what Docker Compose is running

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.10

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component and resiliency YAML. Where v0.0.9 took the dashboard beyond your machine (container image + .NET Aspire mode), v0.0.10 turns it toward the integration-testing workflow: it now discovers Dapr apps launched by Testcontainers, surfaces the component YAML baked into those containers, makes workflows work even without a connected state store, and adds MongoDB as a fourth state-store backend.

What's new

🧪 Testcontainers discovery

• A new scanner detects daprd sidecars started by Testcontainers, keys them by container name, and pairs each one to its app container via the app port — resolving the app's PID and uptime the same way a dapr run process would.
• Container logs stream straight into the Logs page, and lifecycle controls (start/stop/restart) are hidden for these apps since their lifecycle belongs to the test run, not the dashboard.
• Testcontainers apps carry their own source label throughout the UI so it's clear where each app came from.

⚙️ Workflows without a connected state store

• New sidecar-gRPC workflow source: the dashboard talks to each app's daprd directly over gRPC (via the durabletask client), so workflow instances and history light up even when the app uses an in-memory or otherwise unreachable state store.
• Per-app composite routing picks the right source for each app — the shared state-store source where it applies, the sidecar source otherwise.
• Hardening: per-app gRPC call timeouts, and sidecar-sourced items merged only on the first page to keep pagination correct.

🧩 Components extracted from inside the container

• The dashboard now extracts component and resource YAML directly out of Testcontainers containers (via tar extraction) and shows them in the Components view under virtual resource paths.
• App detail gains completeness for these apps: an app-protocol row (read from metadata, with an argv fallback) plus container and session rows.

🍃 MongoDB state store support

• MongoDB joins Redis, SQLite and PostgreSQL as a fully supported state-store backend — available in the supported-store list and the connection dialog, with state.mongodb added to the server connection allowlist.
• Connection handling covers the real-world shapes: compose host translation, a credentials-free connection summary (userinfo stripped), SRV / mongodb+srv support, and host-less database URIs.

🔬 Testcontainers integration harness

• A new integration-test harness spins up real containers for all four backends (SQLite, Redis, PostgreSQL, MongoDB) to verify the state-store connectors end-to-end, with robust container wait strategies.

💅 UI polish

• All modal dialogs now share one consistent layout and alignment.
• The internal styleguide has been refreshed to match.

📸 Docs

• The README now shows dashboard screenshots (Applications and Workflows) so the project reads at a glance.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

With Go (≥ 1.26):

go install github.com/diagridio/dev-dashboard@v0.0.10

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.10

Run:

dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.9

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component and resiliency YAML. This is a big follow-up to v0.0.8 that takes the dashboard beyond your machine: it now ships as a container image and can run inside a .NET Aspire AppHost, discovering your apps from an environment-variable contract instead of scanning the host — the foundation for the upcoming Aspire hosting integration.

What's new

🐳 Run it as a container (.NET Aspire mode)

• First release of the official container image: ghcr.io/diagridio/dev-dashboard — multi-arch (amd64 + arm64), distroless, with DEVDASHBOARD_MODE=aspire baked in, serving on port 8080.
• In aspire mode the dashboard doesn't scan the host at all: the orchestrator tells it what exists via indexed env vars — DEVDASHBOARD_APP_COUNT plus DEVDASHBOARD_APP_<i>_ID / _DAPR_HTTP (and optional _NAMESPACE / _LABEL) per app. Health, metadata, and workflow actions all reach each daprd through its injected base URL.
• Validation is fail-fast and loud: a malformed contract exits at startup naming every offending variable (duplicate app-ids rejected, app count capped), instead of showing a quietly empty dashboard.
• Workflows light up by mounting a state-store component YAML and pointing DEVDASHBOARD_STATESTORE_FILE at it.
• Try it by hand:

docker run --rm -p 8080:8080 \
  -e DEVDASHBOARD_APP_COUNT=1 \
  -e DEVDASHBOARD_APP_0_ID=myapp \
  -e DEVDASHBOARD_APP_0_DAPR_HTTP=http://host.docker.internal:3500 \
  ghcr.io/diagridio/dev-dashboard:latest

🧭 A single mode switch

• New --mode flag / DEVDASHBOARD_MODE env var. Unset (the default) keeps today's behavior — the complete scan across dapr run processes and Docker Compose containers — and now also merges in the env contract when present (contract entries win on app-id collisions). aspire restricts discovery to the contract alone; dapr and compose are reserved for future single-source filtering.

🎛️ Capability-aware UI

• In aspire mode the features that don't apply in a container — app lifecycle (start/stop/restart), Control Plane, and log tailing — are not just hidden but unregistered on the server, and the UI reads injected capability flags so there are no dead buttons or dead-end links.

🔐 Container-grade request security

• Serving beyond loopback gets its own guard: mutating requests are checked same-origin (with correct default-port and case handling), and a new DEVDASHBOARD_ALLOWED_HOSTS allowlist defends against DNS-rebinding attacks. The classic loopback protection for host mode is unchanged.

🗂️ Namespaces & labels from the orchestrator

• Per-app Dapr namespaces from the contract are honored for app-scoped workflow operations (instance details, history, app-filtered lists, force delete).
• Aspire resource labels now show in the Applications list and app detail header when they differ from the app id.

📦 Release pipeline

• Every tagged release now publishes the container image in lockstep with the binaries — same version, same commit. Prerelease tags (e.g. v0.1.0-rc.1) publish their own image tag but never move :latest, and CI builds the image on every PR to catch breakage early.

🧹 Housekeeping

• Datadog RUM telemetry is now tagged with the build version, so sessions can be correlated with releases.
• IPv6 bind addresses (--bind ::) are handled correctly, and binding beyond loopback without aspire mode now warns that remote clients will be rejected.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

With Go (≥ 1.26):

go install github.com/diagridio/dev-dashboard@v0.0.9

Container:

docker pull ghcr.io/diagridio/dev-dashboard:0.0.9

Run:

dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below, and the multi-arch container image is on GHCR.

v0.0.8

Diagrid Dev Dashboard

A local dashboard for Dapr developers that offers a live view of everything Dapr running on your machine, plus guided builders for authoring Dapr component and resiliency YAML. This is a big follow-up to v0.0.7 that turns the dashboard from read-only into a control panel: you can now start, stop, and restart your apps and their Dapr sidecars right from the detail page, the health you see is health you can trust (no more "healthy" while the app is actually dead), and the whole UI has been re-skinned to the Catalyst brand.

What's new

🎛️ Start, stop & restart from the dashboard

• The app detail page now has Start / Stop / Restart controls for the application, its Dapr sidecar, and the whole instance — across all three discovery sources.
• dapr run apps: their launch commands are snapshotted before signalling, so a stopped app stays on the dashboard with a working Start/Restart (SIGTERM→SIGKILL escalation on stop). Whole-instance stop targets the dapr CLI, just like dapr stop.
• Docker Compose: docker start|stop|restart on the app and sidecar containers; the compose scan now uses docker ps -a so stopped containers stay visible with a stopped status.
• Aspire: Stop only, with a "restart it from the Aspire dashboard" hint, so the dashboard doesn't fight the orchestrator.
• Each panel shows a live-ticking Uptime row (resets to — when stopped), with confirm-before-action and error toasts.

❤️‍🩹 Health you can trust

• appStatus is now truthful: discovery verifies the reported app PID (and falls back to a fast TCP dial on the app port) instead of trusting stale metadata — so a dead app no longer shows as healthy.
• Externally killed dapr run instances are detected correctly, and dead CLI PIDs are cleared so signals never land on a stale or reused PID.
• The Applications list and detail header share a single combined health state — green healthy, amber app down / orphaned (with explanatory tooltips), red unhealthy, grey stopped — and the stat cards (Healthy / Starting / Unhealthy) count that state, so an amber row no longer inflates Healthy.

🛟 Orphan detection & safe cleanup

• A standalone Dapr sidecar left running with no supervising CLI and no live app is now flagged as orphaned, with a banner and a safe Stop-only action (start/restart are rejected — a bare daprd can't be resurrected).
• Sidecar Stop/Restart for dapr run apps funnel to the whole instance, so the dashboard can no longer create an orphan by restarting daprd outside the CLI's supervision.

🧭 No more dead ends after lifecycle actions

• Stopping just the app is now fully recoverable — the whole-instance Start re-runs the original dapr run.
• The "App not found" flash after Start is gone; the stopped row is cleaned up only once discovery sees the app again.
• "Remove from list" clears leftover ghosts (stopped standalone and Aspire instances) via a new DELETE /api/apps/{key}, then returns to the overview.
• A "← Back to applications" link on the detail 404 softens every dead-app path.

🎨 Catalyst brand styling

• Typography and accents realigned to the Catalyst product identity — Public Sans self-hosted (bundled, works offline), green-tinted dark surfaces, and a bright-mint accent unified across light and dark themes.
• A clear primary-action hierarchy: affirmative actions (Save, Save connection, wizard Continue/Finish, the New component / New resiliency policy / Add connection CTAs) are promoted to the bright primary button; Disconnect uses the danger outline.

⬆️ Interactive update on start-up

• The dashboard now checks for a newer release on start-up and offers an interactive update, with a link to the terminal output and to the release.

🧹 Housekeeping

• No stray INFO log at start-up.
• Fixed the AppID / container-name swap for Docker Compose apps and the "update available" link.

Install & run

One-liner (macOS / Linux):

curl -sSL https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.sh | sh

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/diagridio/dev-dashboard/main/scripts/install.ps1 | iex

With Go (≥ 1.26):

go install github.com/diagridio/dev-dashboard@v0.0.8

Run:

dev-dashboard          # serves http://localhost:9090 and opens your browser

Single self-contained binary — the React frontend is embedded via go:embed, so there are no runtime dependencies. Prebuilt archives for macOS and Linux (amd64 + arm64) and Windows (amd64) are attached below.