Zsh Plugin Manager Comparison

Antidote is a pure-Zsh plugin manager created as the successor to Antibody. It reads plugins from a ~/.zsh_plugins.txt file (one plugin per line), generates a static load script containing source statements, and your .zshrc sources that generated file. On subsequent shell starts, only the static file is sourced — no re-parsing of plugin declarations occurs. Install is parallel. Loading is effectively a single source call. Antidote supports Oh-My-Zsh and Prezto plugins natively using owner/repo shorthand notation.

Antibody was a Go binary that managed Zsh plugins. It supported a plugins.txt file (similar to Antidote) and could generate a static loading file. It was the predecessor to Antidote — its author deprecated it after native-Zsh managers caught up on performance. Antibody's Go implementation handled parsing and file generation, but the actual plugin sourcing was done by Zsh's source command, meaning the Go binary only reduced config-parsing overhead, not plugin-loading overhead.

Antigen was one of the earliest Zsh plugin managers, inspired by Vim's Vundle/Pathogen. It introduced the antigen bundle command for declaring plugins inline and was the first to bring Oh-My-Zsh plugin compatibility to standalone plugin management. Later versions added static bundle loading and bytecode compilation. Antigen loads plugins by sourcing them sequentially. It has no parallel install capability. Clean startup time is around 60ms, which is slower than modern alternatives.

Sheldon is a shell plugin manager written in Rust. It uses a TOML configuration file (plugins.toml) and generates a static loading script. Because parsing and file generation happen in Rust, the Zsh startup overhead is minimal — the shell only sources the pre-generated file. Sheldon supports plugins from Git repositories (with branch/tag/commit pinning), GitHub Gists, remote scripts, local plugins, and inline plugins. It uses a template system for flexible install methods. It is shell-agnostic, working with both Bash and Zsh.

Zap is a minimal Zsh plugin manager. Plugins are declared inline using plug commands in .zshrc. It clones plugins on first load and sources them directly — no static file generation, no bytecode compilation, no caching. The entire codebase is small. Zap provides zap update, zap list, and zap clean subcommands. It supports local plugins and custom URL prefixes for private repositories. It has no Oh-My-Zsh or Prezto integration.

Zgenom is the maintained fork of zgen. It takes a "generate once, source many" approach: plugins are declared with zgenom load commands inside an if ! zgenom saved; then ... zgenom save; fi block. On first run, it clones plugins and generates a static init script. On subsequent runs, it sources that script directly. Zgenom supports Oh-My-Zsh and Prezto, auto-update on a configurable schedule, --pin for individual plugins, and zgenom compile for bytecode compilation.

Zim is a Zsh configuration framework that bundles a plugin manager with curated modules. It uses a separate ~/.zimrc file with zmodule calls to define modules. It builds a static init.zsh script and aggressively compiles all Zsh files to bytecode. Warm load times are extremely fast — around 0.009s in benchmarks. Zim ships its own modules (environment, git, input, completion, etc.) alongside external plugins. It supports a degit tool (curl/wget-based) as an alternative to git for faster, lighter installs on GitHub repos.

Zinit is the most feature-rich Zsh plugin manager. Its defining feature is "turbo mode" — plugins load asynchronously after the prompt appears, hiding load latency. It also provides bytecode compilation, plugin reports (showing what aliases, functions, and completions a plugin sets up), an annex system for extensibility, and services for background processes. Zinit uses zinit light for plugins and zinit snippet for loading individual files from Oh-My-Zsh or Prezto repos. It has a complex "ice modifier" system (atload, wait, depth, lucid, etc.) that controls how and when plugins load.

Zplug was a feature-rich plugin manager that supported parallel installation, lazy loading, dependency management between plugins, branch/tag/commit pinning, and post-update hooks. It managed plugins from GitHub, Bitbucket, Oh-My-Zsh, Prezto, and local directories. Despite its feature set, Zplug had a poor implementation — clean startup time was around 160ms, significantly slower than alternatives. The project has been abandoned with no recent commits.

Zsh Unplugged is not a plugin manager — it is a ~20-line plugin-load function that demonstrates how to manage Zsh plugins without any manager. It clones repos, finds the appropriate .zsh file, and sources it. The intent is to demystify what plugin managers do and show that for basic configs, a standalone tool is unnecessary. Zcomet is a minimal plugin manager from the same author that formalizes the unplugged approach. It achieves excellent benchmark scores (10% first-prompt lag, 44% first-command lag) with a tiny codebase.