poly>

Package manager · macOS · Linux · Windows

One command.
Every package manager.

Poly installs from pip, npm, and checksum-verified binary releases behind a single unified command. No more remembering which tool owns which package.

See how routing works →

zsh · poly

$ poly search ripgrep
ripgrep 15.1.0 (tap)
  Line-oriented search tool that recursively searches directories for a regex pattern

$ poly install ripgrep
downloading ripgrep  [############################] 100%  1.7MiB/1.7MiB
installed ripgrep 15.1.0 (via tap)
note: tap binaries are installed to ~/.poly/bin, make sure it's on your PATH

$ poly install requests@2.31.0
installed requests 2.31.0 (via pip)

$ poly install npm:cowsay
installed cowsay 1.6.0 (via npm)

$ poly install brew:jq
installed jq 1.8.2 (via brew)

$ poly list
NAME      VERSION  ADAPTER  INSTALLED
cowsay    1.6.0    npm      2026-07-11 15:52
jq        1.8.2    brew     2026-07-11 17:30
requests  2.31.0   pip      2026-07-11 15:52
ripgrep   15.1.0   tap      2026-07-11 15:52
$

Why poly

Six ecosystems, one manifest

Poly works alongside pip and npm instead of replacing them. One command routes to whichever already has your package, and poly.json turns that into a manifest anyone can clone and reproduce with a single poly install.

01 · Auto-routed

poly install <name>

Poly checks its binary tap, then PyPI, then the npm registry, and installs from the first place the package actually exists. No need to remember if a tool ships as a Python package, an npm package, or a standalone binary.

02 · Verified

Checksummed binaries

Tap installs download a release asset over HTTPS, hash it with SHA-256, and compare against a pinned checksum in the formula before anything is extracted or placed on disk.

03 · Pinnable

name@version, anywhere

Append @version to any install, like poly install requests@2.31.0, and it's honored by the pip and npm adapters directly. One syntax, regardless of backend.

Mechanics

How a name resolves to an adapter

When you don't specify a backend, poly tries each adapter's Search in this order and installs through the first one that reports the package exists.

tap → brew → pip → npm → cargo → go

You can also force a specific backend with a prefix:

Command	Resolves to
`poly install ripgrep`	first match: tap → brew → pip → npm → cargo → go
`poly install tap:ripgrep`	forced binary download from the tap formula
`poly install brew:wget`	forced `brew install wget`
`poly install pip:requests`	forced `pip install requests`
`poly install npm:lodash`	forced `npm install -g lodash`
`poly install cargo:ripgrep`	forced `cargo install ripgrep`
`poly install go:golang.org/x/tools/cmd/goimports`	forced `go install <module>@latest`

Tap formulas are plain YAML. A small set ship embedded in the poly binary, and you can drop more into ~/.poly/taps/<name>.yaml to override or extend them.

Install

Get poly

Native installers for macOS and Windows. Both are unsigned (no developer certificates yet), so your OS will warn on first run. That's expected for a young open-source tool.

macOS

Universal .pkg

Intel + Apple Silicon, installs to /usr/local/bin.

Download →

Windows

.exe installer

Installs to %LOCALAPPDATA%\Poly, adds itself to PATH, no admin needed.

Download →

Linux / any OS

Prebuilt binaries

Plain binaries for every platform, no installer, on the releases page.

All releases →

Prefer to build it yourself? One Go toolchain and a few seconds:

# macOS / Linux / Windows (with Go installed)
git clone https://github.com/opencorp2030-ctrl/poly.git
cd poly
go build -o poly .
./poly version

Cross-compiling for another OS/architecture only needs GOOS and GOARCH:

# from any machine, targeting Windows on amd64
GOOS=windows GOARCH=amd64 go build -o poly.exe .

Reference

Commands

Command	Does
`poly install [[adapter:]name[@version] ...]`	install, auto-routed or forced; no args installs from poly.json
`poly remove name`	uninstall, via whichever adapter installed it
`poly list`	show everything poly has installed, and through what
`poly search [adapter:]name`	check existence and latest version across adapters
`poly info [adapter:]name`	version, summary, homepage, install status
`poly init`	write poly.json from what's currently installed
`poly upgrade`	update every installed package to its latest version
`poly self-update`	update poly itself to the latest release
`poly account` / `login` / `logout`	manage your signed-in Poly account
`poly send name version path`	publish a package to the community registry
`poly version`	print the poly build version
`poly doctor`	check for common setup problems

Full reference, including the poly.json format and how to write a tap formula, is on the docs page.

Poly Pro

Support poly, install faster

Poly is and stays 100% free and open source. Pro is a small optional pack: real perks, not a paywall on features that already work.

Real speed

Parallel installs

Free installs packages one at a time. Pro runs poly install a b c concurrently, so multi-package installs actually finish faster: a measurable gain, not a fake one.

Hands-off

Automatic package upgrades

Free runs poly upgrade only when you ask. Pro runs it automatically in the background (throttled, ~once a day) so your tools stay current without thinking about it.

Thanks

You fund development

A supporter badge next to your name in poly version and poly list, and you're directly paying for the next feature to get built.

Answered first

Priority support

Everyone gets the FAQ and docs for free. Pro accounts who email open.corp.2030@gmail.com get answered first.

Get Poly Pro (€0.99)