Open source dashboard framework

Dashboards for developers

Define dashboards as code. Connect APIs. Render real-time interfaces.

Documentation
How it works

From configuration to real-time dashboards.

Dashfy uses a server–client architecture. The server loads dashboard configuration, connects to APIs, and pushes updates over WebSockets to a composable React client.

Step 01

Define dashboards as code

Write declarative configuration in TypeScript, JSON, or YAML. Version, review, and share dashboards alongside your codebase.

Step 02

Connect APIs and data sources

Register extensions like GitHub, system metrics, JSON APIs, or your own custom integrations as data providers.

Step 03

Run the Dashfy server

The server loads configuration, manages API clients, and exposes data to clients through a real-time WebSocket runtime.

Step 04

Render real-time interfaces

The client composes widgets from extensions, receives push updates, and renders responsive dashboards automatically.

Features

Everything you need to ship developer dashboards.

Dashfy ships with the building blocks for production-grade dashboards: declarative config, real-time updates, themes, extensions, and a composable React UI.

Declarative configuration

Define dashboards as structured TypeScript, JSON, or YAML. Versioned, reviewable, reproducible.

Real-time updates

Server-client architecture built on WebSockets and subscriptions. No polling hacks, no manual refresh.

Extension-based

Add widgets and data sources through extensions. Connect to any API or service without forking the core.

Composable layouts

Compose responsive dashboards across screen sizes with a simple grid model and reusable widgets.

Multiple dashboards

Define and rotate through multiple dashboards automatically — perfect for kiosk and TV displays.

Themes and dark mode

Built-in themes, light and dark mode, and full support for custom themes you can ship with your app.

Wake-lock support

Keep dashboards alive on always-on displays without dimming or sleep interrupting your monitoring.

Keyboard shortcuts

Productivity-focused shortcuts for navigating dashboards, panels, and settings without leaving the keyboard.

TypeScript-first

Fully typed configuration, APIs, and widgets for safety, autocompletion, and refactor-friendly DX.

Built for ops

Designed for live displays, internal tools, monitoring screens, and developer-facing dashboards.

Soon

PIN protection

Lock dashboards behind a PIN to keep kiosk and ops displays safe from accidental edits or unauthorized access.

Soon

Agent compiler

Describe your dashboard in natural language and let the AI agent compile it into a typed Dashfy configuration.

Extensions

Works with the tools you already use.

AWSClaude AIGitHubGrafanaJSON / RESTMarket LiveMongoDBNBANotionPostgreSQLPrometheusSentrySlackStripeSystem MonitoringVercel
CloudflareCursorDatadogDiscordDockerFirebaseGeminiGitLabGoogle SheetsJiraKubernetesOpen ClawOpenAIRedisResendSupabaseTelegram
Configuration

Dashboards as code

Three small files take a dashboard from idea to live in the browser.

Define dashboards in YAML

Declarative configuration alongside your codebase. Version, review, and share dashboards as plain text.

dashfy.config.yml
yaml
title: GitHub Dashboard
columns: 3
rows: 2
widgets:
  - extension: github
    widget: RepoBadge
    x: 0
    y: 0
    columns: 1
    rows: 1
    repository: facebook/react
  - extension: github
    widget: PullRequests
    x: 1
    y: 0
    columns: 2
    rows: 1
    repository: vercel/next.js
    state: open
  - extension: json
    widget: JsonStatus
    x: 0
    y: 1
    columns: 3
    rows: 1
    title: API Status
    url: https://api.example.com/health

Register APIs on the server

Set up extensions on the Dashfy server, hand them credentials, and start streaming data over WebSockets.

dashfy.server.ts
ts
import { createGitHubClient } from '@dashfy/ext-github/client'
import { createSystemClient } from '@dashfy/ext-system/client'
import { Dashfy } from '@dashfy/server'

const dashfy = new Dashfy()

await dashfy.configureFromFile('./dashfy.config.yml')

dashfy.registerApi(
  'github',
  createGitHubClient({ token: process.env.GITHUB_TOKEN! }),
)

dashfy.registerApi('system', createSystemClient(), 'push')

await dashfy.start()

Render with the React client

Register widget extensions in the browser and render the live dashboard with a single component.

App.tsx
tsx
import { PullRequests, RepoBadge } from '@dashfy/ext-github'
import { CpuUsageLine, MemoryUsageGauge } from '@dashfy/ext-system'
import { Dashfy, WidgetRegistry } from '@dashfy/ui'

WidgetRegistry.addExtension('github', {
  PullRequests,
  RepoBadge,
})

WidgetRegistry.addExtension('system', {
  CpuUsageLine,
  MemoryUsageGauge,
})

export const App = () => {
  return <Dashfy />
}
Use cases

Built for developers, ops, and live displays.

Whether you're monitoring services, building internal tools, or running TV dashboards, Dashfy keeps your dashboards declarative and real time.

Developer dashboards

Monitor APIs, services, CI/CD pipelines, and infrastructure side-by-side with your code.

Internal tools

Operational dashboards for internal metrics and system health without building a UI from scratch.

API observability

Visualize API responses, service status, and external integrations in real time.

DevOps & infrastructure

Track deployments, system metrics, and service health across environments and clusters.

Real-time systems

WebSockets and subscriptions make Dashfy a fit for live dashboards and operational displays.

Wall displays & kiosks

Fullscreen mode, rotation, and continuous display make Dashfy ideal for TV monitoring screens.

Start building dashboards as code.

Try the live demo, read the docs, or jump straight into the source. Dashfy is open source and ready to drop into your stack.

Loading Dashfy...