brew-browser

Brew Browser

A native macOS GUI for Homebrew — shipped in two builds. A small, fast desktop app for browsing, searching, installing, and snapshotting Homebrew packages. Full source, MIT-licensed, no telemetry, no accounts.

Brew Browser comes in two builds that share one design and one data contract:

• Tauri build — the cross-platform app: macOS 13+ (Ventura and up) and Linux. The shipping, signed-and-notarized download.
• Native build — a fully native Swift 6 + SwiftUI + Liquid Glass app for macOS 26 (Tahoe). The "genuinely native" answer, ~half the memory.

Same features, same brew integration, same privacy posture — see Two builds below.

Tauri build (macOS 13+ · Linux)

Native build (Swift / SwiftUI · macOS 26)

Bundles — capability-gated one-click package stacks, in both builds

Why this exists

Homebrew is the standard package manager on macOS. brew-browser gives it a real native GUI: browse what you have installed, search the full catalog, install / uninstall / upgrade with live output, snapshot your setup to a Brewfile and restore it on a new Mac. Trending packages come from Homebrew's published analytics. The whole thing is a thin, respectful frontend over the brew CLI itself.

Features

• Dashboard — your Homebrew setup at a glance: installed count, updates available, brew version, formula/cask split, top-categories donut chart, storage usage (Cellar / Caskroom / var/log / cache) with one-click "Reveal in Finder" (macOS) / "Show in file manager" (Linux), one-click Run brew doctor and Clean up cache (with a reclaimable-space estimate), and an opt-in Exposure card surfacing known vulnerabilities across your install
• Library — every installed formula and cask in one dense, filterable list, with outdated badges, sortable columns, category chip filters, an opt-in Vulnerable filter pill, inline severity dots, a Pinned filter with per-package pin / unpin (hold packages back from "Update all" — formulae and casks), and a slide-over detail panel
• Discover — search the full Homebrew catalog (16k+ packages, bundled at build time + user-refreshable) by name, browse via the 19-category tile grid, and drill into subcategory groupings for large categories; multi-select chip filter
• Bundles — capability-gated one-click package stacks (Local LLMs, Image Generation, Graphics & Design, Media Toolkit, Web Dev Starter, Local Databases, Agentic Web Dev, LAMP, LEMP). A master list + Details pane like the rest of the app: an intent paragraph, per-package install with live installed state, expandable package descriptions, and a setup checklist where brew-native steps (start a service, open a URL) run in-app while external commands stay copy-only. A zero-install system profile (RAM / arch / GPU / disk) grades each stack Ready / Marginal / Not recommended so an 8 GB Mac isn't told to install a local-LLM stack it can't run. Recipes are validated JSON anyone can contribute against a published contract
• Trending — top packages from Homebrew's published formulae.brew.sh analytics, with 30 / 90 / 365-day windows, sortable columns, a velocity index (recent-month vs prior-11-month adoption signal), and opt-in per-package install-trend sparklines
• Snapshots — save and restore Brewfiles using Homebrew's own brew bundle mechanism; "set up a new Mac" in one click
• Services — list, start, stop, and restart background services managed by launchd through brew services
• Security — opt-in vulnerability scanning. Surfaces known CVEs against your installed formulae via the official brew vulns subcommand (OSV.dev), with optional GHSA enrichment when you're signed into GitHub. Inline severity dots, per-package Security card with "Upgrade to fix" wired to the existing upgrade pipeline. Off by default; one-click installer for brew vulns itself when you opt in
• Activity — every brew invocation streams live into a resizable bottom drawer with full stdout/stderr; session history persists across launches (last 200 jobs, capped lines)

A global Cmd+K command palette covers the verbs. Cmd+0 returns to the Dashboard; Cmd+1…7 jumps between sections (Bundles is ⌘7). Cmd+, opens Settings. Click the brand to return home. Window dragging works from any panel header (native macOS overlay title bar + NSVisualEffectView vibrancy).

What this isn't

• Not a Homebrew replacement — every action shells out to the real brew CLI
• Not telemetry-funded — no analytics, no accounts, no phone-home
• Not freemium — there is no paid tier, because there is no tier

Two builds

Brew Browser is maintained as two implementations of the same app, kept in feature + data-contract parity. They are not competitors — they have different, non-overlapping jobs, because SwiftUI does not run on Linux and Liquid Glass is macOS-26-only.

Both read the same settings.json schema, the same bundled categories.json / enrichment.json, the same brew / brew vulns invocations, and the same trending + enrichment endpoints. A change to a shared data contract lands in both. The memory bank (memory-bank/) is the single canonical spec for both. Rationale and parity rules: memory-bank/decisions.md (2026-06-01 "keep both" ADR).

Install (end users)

Both macOS builds ship on the latest release, signed + notarized — no Gatekeeper warning.

Which download?

Tauri build — macOS 13+ (the cross-platform one)

Direct download: grab the .dmg for your Mac — brew-browser__aarch64.dmg (Apple Silicon) or brew-browser__x64.dmg (Intel) — from the latest release, open it, and drag brew-browser to Applications. Keeps you on the app's own verified updater (Settings → Network → Updates).

Homebrew:

brew tap msitarzewski/brew-browser
brew trust msitarzewski/brew-browser   # Homebrew 6.x requires trusting non-official taps
brew install --cask brew-browser

Installs the same notarized .dmg (Apple Silicon or Intel); update later with brew upgrade --cask brew-browser. The brew trust line is required on Homebrew 6.0+, which refuses to load casks from non-official taps until you trust them — a one-time step.

Tauri build — Linux (newly supported)

Linux bundles are produced by CI as .deb, .rpm, and .AppImage. For tagged releases, grab the .deb or .AppImage from the releases page; for the latest development build, download the artifacts from the most recent Linux Build workflow run. Targets Ubuntu 22.04+ (the webkit2gtk-4.1 ABI) and equivalently-recent distros. Two things to know up front:

• Linux artifacts are currently unsigned. The AppImage ships unsigned by convention; .deb / .rpm GPG signing is a documented future step. There is no Gatekeeper/notarization equivalent to satisfy, but you are running an unsigned binary — verify your download against the release checksums.
• GitHub sign-in needs a Secret Service daemon. The optional GitHub integration stores its token in your system keyring via the Secret Service API (gnome-keyring, KWallet). On a desktop session this is already running; on a headless box or a minimal window manager without a Secret Service provider, GitHub sign-in fails with a "keyring unavailable" message. Everything else — browse, search, install, snapshot, services, vulnerability scanning — works regardless.

Native build — macOS 26 (Tahoe) · Swift / SwiftUI

Direct download: grab the .dmg for your Mac — BrewBrowser--arm64.dmg (Apple Silicon) or BrewBrowser--x86_64.dmg (Intel) — from the latest release, open it, and drag Brew Browser to Applications. It keeps itself current via the in-app Sparkle updater. (Requires macOS 26.)

Build from source

Prereqs (all platforms):

• Rust (stable, edition 2021+)
• Node.js 22+ and npm
• Homebrew itself

Platform build prereqs:

• macOS — Xcode Command Line Tools: xcode-select --install
• Linux — the Tauri 2 GTK/WebKit build dependencies (libwebkit2gtk-4.1-dev, libgtk-3-dev, libayatana-appindicator3-dev, librsvg2-dev, patchelf, plus build-essential). The canonical, always-current apt recipe lives in the CI workflow at .github/workflows/linux-build.yml — copy the apt-get install block from there rather than maintaining a second list here.

Then (same command on every platform):

git clone https://github.com/msitarzewski/brew-browser
cd brew-browser
npm install
npm run tauri dev      # development with HMR
npm run tauri build    # macOS: .dmg · Linux: .deb / .rpm / .AppImage, all under src-tauri/target/release/bundle/

# Intel .dmg (artifacts named _x64, under src-tauri/target/x86_64-apple-darwin/release/bundle/):
rustup target add x86_64-apple-darwin   # one-time
npm run tauri build -- --target x86_64-apple-darwin

Native build (macOS 26)

The native Swift/SwiftUI app lives in native/ as a Swift Package. Requires macOS 26 + a recent Xcode toolchain.

cd native
swift build                 # compile the library + executable
./build-app.sh              # wrap into a launchable Brew Browser.app
open BrewBrowser.app        # run it (use the .app, not `swift run` — Sparkle needs the bundle)
swift test                  # unit tests
./release.sh                # signed + notarized release + Sparkle appcast (maintainer)

Architecture

Tauri build: a Tauri 2 shell hosts a SvelteKit + Svelte 5 frontend in the system WebView. macOS is the primary target; Linux is newly supported (same codebase, built on Ubuntu 22.04+ via CI). A Rust backend exposes 150+ typed Tauri commands that shell out to brew via tokio::process and stream stdout/stderr back over typed IPC channels. Paths are derived from brew --prefix / brew --cache rather than hardcoded, so the Linuxbrew prefix (/home/linuxbrew/.linuxbrew, or ~/.linuxbrew) is picked up automatically alongside the macOS /opt/homebrew. The full Homebrew catalog is bundled at build time (~6 MiB gzipped) and refreshable on demand. Trending data comes straight from formulae.brew.sh's public analytics JSON, cached in memory for an hour. Optional GitHub integration uses OAuth Device Flow with the token stored only in the system keyring (macOS Keychain; Secret Service / gnome-keyring / KWallet on Linux). No shell plugin, no arbitrary command execution — every brew invocation is built in Rust from a small set of enumerated inputs. See docs/PLAN.md for the full design and memory-bank/backendApi.md for the complete