Skip to content
Back to search

gantry

Native macOS app for managing and monitoring Docker — local and over SSH. Agent-ready: built-in MCP server and App Intents. Free and open source.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/getgantry/gantry with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/getgantry/gantry'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/getgantry--gantry/badge.svg)](/listings/getgantry--gantry)

HTML

<a href="/listings/getgantry--gantry"><img src="/api/listings/getgantry--gantry/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Homebrew

brew install --cask getgantry/tap/gantry
xattr -dr com.apple.quarantine /Applications/Gantry.app

The `xattr` step clears the quarantine flag — the app is not notarized and macOS refuses to open it otherwise.

**Updating:** because the app is ad-hoc signed (not notarized), in-app Sparkle auto-updates can't launch their installer under Gatekeeper, so updates go through Homebrew:

brew upgrade --cask gantry        # or: brew reinstall --cask gantry
xattr -dr com.apple.quarantine /Applications/Gantry.app

Manual

1. Download the latest zip from [Releases](https://github.com/getgantry/gantry/releases/latest) 2. Unzip and drag **Gantry.app** to Applications 3. First launch: right-click the app and choose **Open** (the app is not notarized), or clear quarantine:

   xattr -dr com.apple.quarantine /Applications/Gantry.app

Requires **macOS 26 (Tahoe)** or later. Works with Docker Desktop, OrbStack, Colima, or a plain remote `dockerd` — the socket is auto-discovered (`$DOCKER_HOST`, `~/.docker/run`, `~/.orbstack/run`, `~/.colima`, `/var/run`).

Updates arrive automatically via Sparkle once installed.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 374 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Gantry
  2. **Native Docker management for your Mac. Local and over SSH. Agent-ready with a built-in MCP server. Free, open source, no limits.**
  3. [![CI](https://github.com/getgantry/gantry/actions/workflows/ci.yml/badge.svg)](https://github.com/getgantry/gantry/actions/workflows/ci.yml)
  4. [![Release](https://img.shields.io/github/v/release/getgantry/gantry)](https://github.com/getgantry/gantry/releases/latest)
  5. [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
  6. [![macOS 26+](https://img.shields.io/badge/macOS-26%2B-black)](https://github.com/getgantry/gantry/releases/latest)
  7. [![MCP](https://img.shields.io/badge/MCP-server%20included-8A2BE2)](#agent-friendly)
  8. Gantry is a fully native macOS app (SwiftUI, Swift 6) for managing and monitoring
  9. Docker — the local daemon and any number of remote hosts over SSH — plus
  10. [apple/container](https://github.com/apple/container) hosts on your Mac. No
  11. Electron, no subscription, no artificial limits. It is built to be driven by AI agents
  12. too: a bundled [MCP server](#agent-friendly) and App Intents expose your Docker
  13. hosts to Claude, Shortcuts, Siri and scripts.
  14. Website: **[Gantry — native Docker & apple/container app for Mac](https://getgantry.github.io/)**
  15. ![Fleet dashboard](assets/dashboard.png)
  16. ## Features
  17. ### Core
  18. - **Containers** — list, inspect, start/stop/restart/kill/pause, rename, remove,
  19. create and run with ports/env/volumes/restart-policy, commit to image,
  20. export filesystem, view processes (`top`), update restart policy
  21. - **Images** — list, **build from a Dockerfile** (drag-and-drop, live build log),
  22. history, tag, pull with per-layer progress, remove, prune
  23. - **Private registries** — pulls resolve credentials from your
  24. `~/.docker/config.json` (inline `auth`, credential helpers, macOS Keychain),
  25. the same `docker login` you already ran — so create-and-run, Quick Run and
  26. Compose pull private images, not just the manual Pull sheet
  27. - **Volumes / Networks** — list, inspect, create, remove, prune,
  28. connect/disconnect containers; volumes show their on-disk size and sort by
  29. name, size, driver or creation date
  30. - **Docker Compose** — containers grouped by compose project with collapsible
  31. sections and group start/stop/restart; **run a compose file on any host**
  32. (local Docker, SSH or apple/container — the runner adapts per engine) with an
  33. inline **YAML editor**, and open **merged stack logs** for a whole project
  34. - **System** — disk usage (`docker system df`), prune build cache
  35. - **Smart Cleanup** — a *Reclaim Space* panel that shows dangling images,
  36. stopped containers, unused volumes and build cache with their sizes and prunes
  37. each, or all at once, reporting how much was freed
  38. ### Live
  39. - **Logs** — streamed in real time with follow mode, **regex** or literal
  40. Cmd+F search with match highlighting and next/previous navigation, a
  41. **minimum-level filter** (Error/Warn/Info/Debug/Trace), **ANSI color**
  42. rendering, and a 50k-line virtualized buffer
  43. - **Stats** — CPU, memory, network and disk I/O charts (Swift Charts), 1s sampling
  44. - **Events-driven UI** — lists update live from the Docker events stream,
  45. with polling fallback
  46. ### Notifications
  47. - **Failure alerts** — a native macOS notification the moment a container
  48. crashes (non-zero exit), runs out of memory, or fails its health check, on
  49. any host (local, SSH, apple/container). Derived from the live events stream
  50. - **Click through** — opening a notification activates Gantry and jumps
  51. straight to the offending container's detail view
  52. - **No false alarms** — stops, restarts, kills and removes you trigger from
  53. Gantry are never reported as crashes, and an unhealthy container alerts once
  54. per episode, not on every health re-check. Toggle the whole thing in
  55. Settings ▸ General
  56. ![Live stats](assets/stats.png)
  57. ### Fleet & hosts
  58. - **Fleet dashboard** — every connected host on one screen: live CPU/memory
  59. sparklines (10-minute rolling window), container state breakdown, host facts;
  60. opens at launch
  61. - **Health column** — failed connections and unhealthy / restarting / dead
  62. containers across all hosts, each row jumping straight to the culprit
  63. - **Host overview** — CPU/memory gauges, Docker disk usage, daemon facts
  64. - **Host terminal & files (SSH hosts)** — a shell on the host itself and an
  65. SFTP file browser, alongside the per-container ones
  66. - **Auto-reconnect** — dropped tunnels and transient connect failures retry
  67. with backoff; stale data stays on screen instead of blanking out
  68. ### Terminal & Files
  69. - **Exec terminal** — full terminal emulation (SwiftTerm) into any running
  70. container, local or remote
  71. - **Debug shell** — a shell for containers that don't have one. Distroless
  72. images have no `/bin/sh` at all, slim ones are missing `curl`, `ps` and `ip`,
  73. and a read-only container can't be given them. Switch the Terminal tab to
  74. **Debug** (or right-click a container ▸ *Open Debug Shell*) and Gantry
  75. attaches a toolbox sidecar sharing the container's process and network
  76. namespaces: its processes are listed, its filesystem is the working
  77. directory, and `curl localhost:8080` reaches its own listener. The container
  78. itself is never modified, so this works on distroless and read-only alike.
  79. Docker hosts, local and over SSH; the toolbox image is configurable
  80. - **File browser** — browse the container filesystem, download and upload files,
  81. **drag & drop** between Finder and the container (tar-packed transparently)
  82. - **Drop any folder into a container** — upload whole folder trees from the
  83. picker or by dropping them from Finder. Works on every engine, including
  84. apple/container (where there is no archive endpoint, it streams a tar through
  85. `tar -x` over exec)
  86. ### Ports & networking
  87. - **Open in browser** — one click on a published port opens it in your browser:
  88. directly for local Docker and apple/container, through an automatic forward
  89. for SSH hosts
  90. - **Local port forwarding (SSH)** — forward a remote container port to
  91. `localhost` (an `ssh -L`-style tunnel over a dedicated connection). If the
  92. local port is taken, Gantry picks a free one — and you can edit it. Active
  93. forwards are listed with open/copy-URL/stop controls
  94. - **Share publicly via Cloudflare Tunnel** — one click on a published port
  95. exposes it to the internet over [Cloudflare Tunnel](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/).
  96. Gantry installs `cloudflared` via Homebrew if it's missing, then starts either
  97. a **quick tunnel** (no Cloudflare account, an ephemeral `*.trycloudflare.com`
  98. URL) or a **named tunnel** on your own hostname (after `cloudflared tunnel
  99. login`). The public URL shows under the port with open/copy/stop. SSH-host
  100. ports are forwarded locally first, and tunnels are torn down on disconnect —
  101. great for sharing a dev server or letting an AI agent or webhook reach a
  102. container running on your Mac
  103. ### Remote hosts over SSH
  104. - Connects exactly like `docker -H ssh://user@host`: an SSH exec channel runs
  105. `docker system dial-stdio` and Gantry speaks HTTP/1.1 to the remote daemon
  106. over it — nothing to install on the server beyond Docker itself
  107. - Reads `~/.ssh/config` (aliases, HostName, User, Port, IdentityFile,
  108. **ProxyJump** — bastion chains with per-hop auth and host key checks);
  109. the Add Host sheet offers one-click import of your config hosts and of
  110. `ssh://` **Docker contexts** (`docker context ls`)
  111. - ed25519 and RSA keys (openssh-key-v1, optional passphrase), password auth;
  112. RSA signs with **rsa-sha2-256** so it works against modern OpenSSH servers
  113. - Host key verification with trust-on-first-use prompts (SHA256 fingerprints),
  114. honoring `~/.ssh/known_hosts`; secrets live in the macOS **Keychain**
  115. ### apple/container hosts
  116. - Add an **Apple Container** host to manage Linux containers run by
  117. [apple/container](https://github.com/apple/container) side by side with your
  118. Docker hosts
  119. - **Zero-setup onboarding** — on first launch (and after Gantry updates) it
  120. checks for the `container` CLI and offers to install or upgrade a supported
  121. version through Homebrew for you, so the runtime is ready before you add a host
  122. - Driven through the `container` CLI and translated to the same engine
  123. interface, so lifecycle, live logs, exec terminal, stats, create-container,
  124. images (pull/tag/delete/prune), volumes, networks and disk usage all work
  125. from the same UI — and through the MCP server and App Intents
  126. - Connecting the host starts the `container` services if they are down
  127. - **Service control** — start/stop the `container` background services from the
  128. menu bar and Settings ▸ Apple, with live running/stopped status
  129. - **Open by IP & hostname** — every apple/container gets a routable IP on your
  130. Mac; the container's Overview surfaces that address (and, when it was launched
  131. on a local domain, its `name.domain` hostname) with one-click open-in-browser
  132. per port
  133. - **Local DNS domains** — create/list/delete apple/container DNS domains from
  134. Settings ▸ Apple (admin-approved), and **star a default**: Gantry writes it
  135. into apple/container's `config.toml` and restarts the services for you, so the
  136. whole flow works without touching the CLI
  137. - **Automatic DNS names** (OrbStack-style) — new containers are assigned the
  138. default domain automatically with a unique, image-derived name, so each one
  139. resolves as `name.domain` across your Mac; the resolver cache is flushed so it
  140. works immediately. A DNS domain can also be chosen in **New Container** and
  141. **Quick Run**
  142. - **Assign / Change DNS Name** — set or change a container's domain after
  143. creation from its Address section. apple/container fixes the domain at create
  144. time, so Gantry recreates the container, preserving its image, command,
  145. environment, published ports, volume binds, restart policy and labels (named
  146. volumes are kept)
  147. - **Quick Run** — an OrbStack-style quick-launch sheet: pick a local image, name
  148. it, share a macOS folder, map ports and pick a DNS domain, then run — and the
  149. container's address opens straight in the browser
  150. - **Run docker-compose files from Finder** — right-click a `docker-compose.yml`
  151. and choose *Open With ▸ Gantry* or *Quick Actions ▸ Compose Up in
  152. apple/container* (or File ▸ Open Compose File…). Gantry parses the file,
  153. builds any `build:` services, creates the project's network and named
  154. volumes, and starts every service in `depends_on` order with the standard
  155. `com.docker.compose.*` labels — so the project groups in the sidebar just
  156. like Compose on Docker. apple/container has no native `compose`; Gantry does
  157. the orchestration itself over the `container` CLI
  158. - **Machines** — list, create, start/stop, delete and set-default the long-lived
  159. Linux environments `container machine` provides, with an editable CPU/memory
  160. panel, an interactive shell and a raw inspect view. On apple/container 1.1+ a
  161. machine can also boot with **nested virtualization** and a **custom kernel**,
  162. so you can run VMs (or another container runtime) inside one — offered only
  163. when the Mac supports it, Apple silicon M3 or newer on macOS 15+
  164. - **Unix socket mounts** — bind a socket from your Mac into a container and
  165. Gantry flags whether the installed CLI propagates its permissions to non-root
  166. containers (apple/container 1.1+)
  167. - **Custom kernels per container** — boot a container from your own kernel
  168. binary and append raw **boot arguments** to its command line, straight from
  169. the New Container sheet. Useful for kernel features the stock command line
  170. leaves off, such as enabling the BPF LSM. Arguments need apple/container
  171. 1.2+; the kernel path works on any supported CLI
  172. - **DNS defaults for new containers** (apple/container 1.7+) — edit the
  173. `[container.dns]` name servers, search domains and options in System ▸
  174. Properties; Gantry keeps the comments and other keys of `config.toml`
  175. - **Outdated builder image** — the Image Builder pane tells you when the builder
  176. runs an older image than the CLI expects and offers to recreate it
  177. - **Cluster services check** — when `container cluster` commands fail because
  178. the cluster services are missing (for example a Homebrew build without them)
  179. or stopped, the Clusters section says why and offers the fix
  180. - CPU use comes from the CLI's own `cpuUtilization` value on apple/container
  181. 1.7.1+, so it shows from the first sample; older CLIs use the counter math
  182. - Features the platform does not offer (pause, rename, commit, restart
  183. policies, network attach, image history, file *download*) are hidden
  184. for these hosts instead of erroring
  185. ![Host overview](assets/overview.png)
  186. ### Mac-native
  187. - Three-column split view, Liquid Glass materials, dark/light/system appearance
  188. - Collapsible host sections in the sidebar; reorder hosts via Move Up/Down
  189. - Menu bar panel listing running containers per host — open one in your browser,
  190. copy its `dns`/`ip:port`, stop/restart inline, or click through to its details
  191. - Keyboard shortcuts (Cmd+R refresh, Cmd+N new container, Cmd+F log search)
  192. - **Terminal themes** (System, Solarized Dark, Dracula, Nord) for the embedded shell
  193. - Optional **Touch ID** confirmation before removing a container or deleting a host
  194. - Auto-updates via **Sparkle** (EdDSA-signed appcast)
  195. ### Agent-friendly
  196. - **App Intents** — list/start/stop/restart containers and fetch logs from
  197. Shortcuts, Siri, Spotlight, or scripts (`shortcuts run`); works even when
  198. the app is closed
  199. - **MCP server** — a bundled `gantry-mcp` binary exposes the whole app as
  200. [Model Context Protocol](https://modelcontextprotocol.io) tools over stdio, so
  201. AI agents can manage your Docker hosts (including SSH ones) with the same reach
  202. as the GUI:
  203. ```sh
  204. claude mcp add gantry -- /Applications/Gantry.app/Contents/Resources/gantry-mcp
  205. ```
  206. Tools cover containers (list, lifecycle, **create**, rename, commit, restart
  207. policy, processes, inspect, logs, stats, exec, **debug exec** — run a command
  208. against a container with no shell of its own, **read/write files**, prune),
  209. images (**pull**, **build**, tag, remove, history, inspect, prune), volumes and
  210. networks (create, remove, inspect, connect/disconnect, prune), system disk
  211. usage and build-cache prune, **apple/container machines, services and DNS
  212. domains**, **Docker Compose up**, and exposing a port publicly via a
  213. **Cloudflare Tunnel** or an **SSH port forward**. Streaming operations (pull,
  214. build, compose) run to completion and return their log; tunnels and forwards
  215. live as long as the server process. Headless SSH connections only use hosts
  216. whose keys you already trusted in the app.
  217. - **Copy as Prompt** — every container (list, detail view with ⌥⌘P, menu bar,
  218. dashboard issues) can be copied as a paste-ready debugging prompt for an AI
  219. coding agent. The prompt carries the host and how to reach it (the exact
  220. `ssh` command or the local socket), the Gantry MCP `host_id` and tool names,
  221. the container's identity and state — image, health, exit code, restarts,
  222. ports, compose project — and a task matched to the symptom: unhealthy asks
  223. to debug the failing health check, crash-looping to find the crash, healthy
  224. leaves room for your own question. Paste into Claude Code and let it dig in.
  225. ## Install
  226. ### Homebrew
  227. ```sh
  228. brew install --cask getgantry/tap/gantry
  229. xattr -dr com.apple.quarantine /Applications/Gantry.app
  230. ```
  231. The `xattr` step clears the quarantine flag — the app is not notarized and
  232. macOS refuses to open it otherwise.
  233. **Updating:** because the app is ad-hoc signed (not notarized), in-app
  234. Sparkle auto-updates can't launch their installer under Gatekeeper, so updates
  235. go through Homebrew:
  236. ```sh
  237. brew upgrade --cask gantry # or: brew reinstall --cask gantry
  238. xattr -dr com.apple.quarantine /Applications/Gantry.app
  239. ```
  240. ### Manual
  241. 1. Download the latest zip from [Releases](https://github.com/getgantry/gantry/releases/latest)
  242. 2. Unzip and drag **Gantry.app** to Applications
  243. 3. First launch: right-click the app and choose **Open** (the app is not
  244. notarized), or clear quarantine:
  245. ```sh
  246. xattr -dr com.apple.quarantine /Applications/Gantry.app
  247. ```
  248. Requires **macOS 26 (Tahoe)** or later. Works with Docker Desktop, OrbStack,
  249. Colima, or a plain remote `dockerd` — the socket is auto-discovered
  250. (`$DOCKER_HOST`, `~/.docker/run`, `~/.orbstack/run`, `~/.colima`, `/var/run`).
  251. Updates arrive automatically via Sparkle once installed.
  252. ## Building from source
  253. ```sh
  254. git clone https://github.com/getgantry/gantry.git
  255. cd gantry
  256. open Gantry.xcodeproj # Xcode 26+, build the "Gantry" scheme
  257. ```
  258. No setup steps. The project is a thin hand-written `.xcodeproj` whose code
  259. lives in local Swift packages.
  260. ### Repository layout
  261. ```
  262. App/ SwiftUI app target (views, intents, app shell)
  263. Packages/
  264. DockerKit/ Docker Engine API client
  265. Transport/ unix socket (async-http-client), SSH dial-stdio glue,
  266. raw-NIO hijack for exec, hand-rolled HTTP/1.1 codec
  267. Endpoints/ containers, images, volumes, networks, exec, archive,
  268. system, streaming (logs/stats/events)
  269. Streams/ multiplexed log demuxer, JSON-lines decoder,
  270. stats model with the docker CLI CPU/memory formulas,
  271. tar reader/writer
  272. SSHKit/ SSH layer on Citadel: key loading, ssh_config parser,
  273. known_hosts + TOFU, SSHDialStdioTransport, local port
  274. forwarding (SSHPortForward)
  275. AppCore/ @Observable stores, hosts persistence, Keychain,
  276. headless connections for Intents/MCP
  277. GantryMCP/ stdio MCP server executable (bundled into the app)
  278. scripts/release.sh release build + Sparkle appcast
  279. Tools/ app icon generator
  280. ```
  281. ### How the SSH transport works
  282. `docker -H ssh://` does not forward the remote unix socket. It runs
  283. `docker system dial-stdio` on the server, which bridges the SSH channel's
  284. stdin/stdout to the daemon socket. Gantry does the same with
  285. [Citadel](https://github.com/orlandos-nl/Citadel): one persistent exec channel
  286. carries serialized HTTP/1.1 requests (FIFO, keep-alive), and every streaming
  287. endpoint (logs, stats, events, exec) gets a dedicated channel so nothing blocks.
  288. A `101 Upgraded` response switches the parser into raw passthrough — that is
  289. how the interactive terminal rides the same machinery.
  290. ### About the forks
  291. Gantry currently builds against two small forks, both intended for upstreaming:
  292. - [andrewkomkov/swift-nio-ssh](https://github.com/andrewkomkov/swift-nio-ssh)
  293. (`gantry-fixes`) — fixes a process-killing `preconditionFailure` when a
  294. pending read delivers a window adjust on a locally closed channel, and lets
  295. a key type declare a distinct userauth algorithm name
  296. - [andrewkomkov/Citadel](https://github.com/andrewkomkov/Citadel) (`gantry`) —
  297. RSA signing with rsa-sha2-256 (RFC 8332) instead of legacy ssh-rsa, which
  298. modern OpenSSH servers reject
  299. ### Tests
  300. ```sh
  301. swift test --package-path Packages/DockerKit # parsers, codecs, tar, exec
  302. swift test --package-path Packages/SSHKit # ssh_config, known_hosts, keys
  303. ```
  304. Live integration tests are **gated**: they run automatically only when a local
  305. Docker socket exists (lists, streaming, exec, pull, prune, archive) or when the
  306. SSH test host is reachable (dial-stdio, exec, stream-cancellation stress, RSA
  307. auth). On CI they skip cleanly.
  308. ### Releasing
  309. ```sh
  310. scripts/release.sh 0.6.0
  311. gh release create v0.6.0 dist/Gantry-0.6.0.zip --title "Gantry 0.6.0"
  312. git add appcast.xml CHANGELOG.md && git commit -m "Release 0.6.0" && git push
  313. ```
  314. The script builds the app, embeds `gantry-mcp`, zips, signs the Sparkle appcast
  315. entry (EdDSA key in the login Keychain), and stamps the `## [Unreleased]`
  316. section of [`CHANGELOG.md`](CHANGELOG.md) with the version and date — so the
  317. only manual changelog work is adding bullets under **Unreleased** as you go.
  318. ## Known limitations
  319. - Not notarized (no Apple Developer ID) — first launch needs right-click Open
  320. - ECDSA private keys in OpenSSH format are not supported (ed25519/RSA are)
  321. - Remote hosts need `docker` on `PATH` for `dial-stdio` (any recent version)
  322. ## License
  323. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.