This page is a direct transcript of hop help <command> for every command in the CLI, as of the version this site tracks — nothing here is summarized or paraphrased from memory of what a command does.
hop <command> [flags] [arguments]. Flags in brackets are optional; a name in <angle brackets> is required. The eight global flags at the bottom (--yes, --dry-run, --json, and so on) work on every single command below, so they're listed once rather than repeated forty times.
The commands that actually change what's installed. Every one of them is a single transaction: hop downloads and verifies everything first, and only then flips one symlink to make the change live.
Install one or more packages and everything they depend on. Downloads run in parallel, and an artifact already in the store is reused without touching the network. If anything fails, nothing changes — your environment is left exactly as it was. Works for GUI apps (Homebrew casks) too — those land in ~/Applications instead of on PATH; see how.
Remove packages from the active set. Dependencies that nothing else needs are removed too, so uninstalling doesn't leave orphans behind. Removal is bookkeeping only — the package stays in the store until hop gc runs, which is why hop rollback can bring it straight back.
Upgrade the named packages, or everything if you name none. Like install, this is one transaction across every package — either they all move, or none do. The previous versions stay in the store, so hop rollback undoes the whole upgrade instantly.
hop self-update: this upgrades installed packages. self-update upgrades hop itself. Neither touches what the other manages.Reinstall packages at their current indexed version — the same store path is re-verified and re-linked, useful if something in a generation looks damaged without wanting to change what version you're on.
Read-only commands. None of these touch the store, a generation, or the network beyond a search query.
List installed packages.
Search package names, keywords and descriptions. Results are ranked: exact name matches first, then prefixes, then keywords and descriptions — a query with a typo still finds its target.
Show everything known about a package: version, description, dependencies, and which platforms it's built for.
Show which package provides a command — useful when a binary name doesn't obviously match a package name.
List installed packages with newer versions available in the index, without changing anything.
Show a package's dependency tree.
Per-project reproducibility: a hopfile.toml declares what a project needs, and an optional hop.lock pins the exact resolved versions so a second machine gets identical bytes.
Find what Homebrew has installed and reinstall it under hop. Reads Homebrew's Cellar and install receipts directly — brew doesn't have to be running, and nothing about the Homebrew installation is touched. Only formulae installed on request are considered by default; brew's own internal library dependencies are left out, since hop resolves its own. Nothing is removed from Homebrew — hop prints the exact brew uninstall commands to run yourself. Casks (GUI apps) are reported but not migrated.
Create a hopfile: a declarative list of the tools a project needs. Commit it alongside your code and anyone can reproduce your toolchain with a single hop sync.
Install packages and add them to this project's hopfile — exactly like hop install, except the hopfile is updated so the choice is recorded for everyone else working on the project.
Install, upgrade and remove packages until this machine matches the hopfile. With a hop.lock present, sync installs the exact versions it pins, so two machines end up byte-identical.
Write hop.lock, pinning the resolved versions for every package the hopfile names.
Every install, upgrade or removal creates a new, numbered generation. Nothing is ever deleted by these two commands — Architecture covers the mechanism in full.
List every generation of the installed set. Old generations remain on disk, so any of them can be restored instantly with hop rollback <n>.
Restore a previous generation. With no argument, rollback goes to the generation before the active one. Because every version is still in the store, this is a single symlink swap — microseconds, no download, however large the change. Rolling back is itself just an activation, so running it again returns you to where you were.
Hot-swap one tool to a version you've had installed before, without touching the rest of the active set. With no version, lists what that package has been at — every version hop has installed for you stays in the store, so switching to one is a symlink swap: instant, no download. This only reaches versions installed on this machine before; the recipe index tracks the current release only.
Housekeeping: reclaiming disk, checking the installation is healthy, and keeping the index and hop itself current.
Delete store paths and cached downloads that no generation needs — a real mark-and-sweep, not "delete anything old." By default every generation is kept, so only genuinely unreachable data is removed. The active generation is never deleted. Coming from Homebrew, hop prune and hop clean are the same command under a different name — reach for whichever one your fingers already know.
Check the installation for problems: prefix permissions, whether hop's bin directory is on PATH, and whether the active generation is intact.
Check that installed packages are intact on disk — a deeper check than doctor, walking the actual store contents.
Refresh the recipe index from HOP_INDEX_URL — one conditional HTTP request, usually a 304, done in milliseconds. With no HOP_INDEX_URL set, hop uses the index built into the binary and this command has nothing to do.
Check GitHub for hop's latest published release and, if it's newer than the version currently running, download it, verify its checksum against the release's own SHA256SUMS, and replace the running binary in place. The replacement is atomic: the new binary is written alongside the old one and renamed over it, so an interrupted self-update never leaves a half-written executable, and anything already running keeps working off the old file until it exits.
hop self-update is what you run when you see that hint.
Remove hop completely: every generation, every store path, the download cache, and finally hop's own binary. The one command in hop that isn't reversible — there's no hop rollback afterward, because there's no hop left to run it. A GUI app gets one courtesy step first: its symlink in ~/Applications is removed, so nothing is left pointing at a store that's about to disappear.
eval "$(hop shellenv)" to ~/.zshrc or similar, this prints the line to remove yourself, the same way migrate prints brew uninstall commands rather than running them.Getting hop itself onto your PATH, and shell integration.
Show hop's own version. hop -V and hop --version also work, before any command is even resolved.
Print the shell commands that put hop on PATH — prepends <root>/current/bin. Because that path goes through the "current" symlink, it never changes as you install, upgrade or roll back; your shell config is written once and stays correct.
Print a shell completion script for the named shell.
Every command above accepts all of these: