Desktop App

A native desktop application for macOS, Windows, and Linux that mirrors the Dashboard TUI in a graphical window. Built with Wails and React.

The desktop app connects to your running Pilot daemon via the gateway API. Start pilot start in a terminal first, then open Pilot.app alongside it.

The desktop app is not yet code-signed. macOS will show a Gatekeeper warning on first launch — right-click the app and select Open to proceed. Windows may show a SmartScreen warning — click More info then Run anyway.

Download

Download the latest release for your platform:

Platform	Download	Format
macOS (Intel + Apple Silicon)	Pilot-Desktop-macOS-universal.dmg	DMG (recommended)
macOS	Pilot-Desktop-macOS-universal.zip	ZIP
Windows (amd64)	Pilot-Desktop-Windows-amd64.zip	ZIP
Linux (amd64)	Pilot-Desktop-Linux-amd64.tar.gz	tar.gz

Installation

macOS

Download the DMG

Open the .dmg file and drag Pilot.app into your Applications folder.

Bypass Gatekeeper on first launch

Since the app is unsigned, macOS will block it on first open. Right-click (or Control-click) Pilot.app and select Open, then click Open in the dialog.

Alternatively, remove the quarantine attribute from a terminal:


xattr -cr /Applications/Pilot.app

Launch

Open Pilot.app from Applications as usual.

Windows

Extract the ZIP

Download Pilot-Desktop-Windows-amd64.zip and extract it to any folder (e.g. C:\Program Files\Pilot\).

SmartScreen warning

Windows may show a SmartScreen warning because the app is unsigned. Click More info, then click Run anyway.

Launch

Run Pilot.exe from the extracted folder.

Linux


# Extract the archive
tar xzf Pilot-Desktop-Linux-amd64.tar.gz
 
# Run directly
./Pilot
 
# Or install system-wide
sudo cp Pilot /usr/local/bin/pilot-desktop

To add a desktop entry, create ~/.local/share/applications/pilot.desktop:


[Desktop Entry]
Name=Pilot
Exec=/usr/local/bin/pilot-desktop
Type=Application
Categories=Development;

Usage

Start the Pilot daemon in a terminal:


pilot start --github --env dev

Open Pilot.app (from Applications, your install location, or desktop/build/bin/).

The desktop app reads ~/.pilot/config.yaml to determine the gateway address and connects to the daemon automatically. If the daemon is not running, panels display empty state and retry on each poll cycle.

Dashboard Panels

The desktop app displays the same panels as the terminal dashboard:

Panel	Description
Header	Logo, version, and daemon connection status
Metrics Cards	Tokens, cost, and queue depth with 7-day sparklines
Queue	Active, queued, and pending tasks with progress bars
Autopilot	Mode, auto-release status, and active PR tracking
History	Recent completed tasks with success/failure indicators
Logs	Live execution log entries from the daemon

Metrics are read from the shared SQLite database at ~/.pilot/pilot.db, so data persists across restarts and is shared between the TUI and desktop app.

Configuration

The desktop app reads the same ~/.pilot/config.yaml as the CLI. The gateway address is derived from:


gateway:
  host: "127.0.0.1"
  port: 9090

If no config exists or the gateway section is missing, the app defaults to http://127.0.0.1:9090.

No additional configuration is required for the desktop app itself.

Build from Source

For contributors who want to build from source rather than using pre-built binaries.

Prerequisites

Go 1.24+ — golang.org/dl
Node.js 18+ — for the frontend build
Wails CLI v2 — install with go install github.com/wailsapp/wails/v2/cmd/wails@latest

Verify Wails is installed:


wails doctor

Clone the repository


git clone https://github.com/anthropics/pilot
cd pilot

Build the app


make desktop-build

This installs frontend dependencies (npm ci) and compiles a universal macOS binary via Wails. The output is at:


desktop/build/bin/Pilot.app

(Optional) Package as a zip


make desktop-package VERSION=v2.56.0

Produces bin/Pilot-macOS-v2.56.0.zip.

Development

For hot-reload during frontend development:


make desktop-dev

This runs wails dev, which starts a Vite dev server for the React frontend and rebuilds the Go backend on changes. The app window opens automatically.

Project structure


desktop/
├── main.go              # Wails entrypoint
├── app.go               # Go backend — metrics, queue, autopilot APIs
├── types.go             # Shared type definitions
├── wails.json           # Wails project config
├── build/
│   ├── appicon.png
│   ├── darwin/Info.plist
│   ├── windows/         # Windows icon, manifest, version info
│   └── linux/           # .desktop file for app launcher
└── frontend/
    ├── src/
    │   ├── App.tsx              # Root component
    │   ├── components/          # Panel components
    │   │   ├── Header.tsx
    │   │   ├── MetricsCards.tsx
    │   │   ├── QueuePanel.tsx
    │   │   ├── AutopilotPanel.tsx
    │   │   ├── HistoryPanel.tsx
    │   │   └── LogsPanel.tsx
    │   └── hooks/
    │       ├── useDashboard.ts  # Data fetching hook
    │       └── usePolling.ts    # Poll interval logic
    ├── package.json
    └── vite.config.ts

Make targets

Target	Description
`make desktop-deps`	Install frontend dependencies
`make desktop-dev`	Run in development mode with hot reload
`make desktop-build`	Build production `Pilot.app` (darwin/universal)
`make desktop-build-windows`	Build for Windows (amd64)
`make desktop-build-linux`	Build for Linux (amd64)
`make desktop-package`	Build and zip for distribution (`VERSION=vX.Y.Z`)
`make desktop-dmg`	Build and create macOS DMG (`VERSION=vX.Y.Z`)
`make desktop-clean`	Remove build artifacts and node_modules