In a world where developers increasingly rely on graphical interfaces, cloud-hosted editors, and browser-based tooling, there exists a countermovement — a digital underground of power users who believe the terminal is not merely a tool but a way of life. ZPWR stands as a monument to that philosophy. Born from a fork of Hashrocket's Dotmatrix project and hand-forged over years into a sprawling system of more than 50,000 lines of code, ZPWR is a cyberpunk-themed terminal operating system built on the trinity of zsh, tmux, and vim. Its tagline captures its ethos with poetic precision: "If your terminal isn't glowing, you're not running ZPWR."
ZPWR is not a dotfiles repository in the conventional sense. It is an opinionated, batteries-included distribution for the command line — a neural interface that transforms a blinking cursor into a neon-coded cockpit for software development, system administration, and digital exploration.
The architecture of ZPWR is a study in centralization and modularity held in careful tension. The entire system resides within a single directory — typically ~/.zpwr — comprising roughly 1,675 files totaling 197 megabytes. This centralization is deliberate: no ghost processes, no scattered dotfiles, no orphaned configuration fragments. A clean zpwr uninstall removes everything. The system can be understood through its major structural components.
At the foundation lies the environment system, a network of over 175 environment variables that act as dials and switches governing every subsystem. These variables — stored in .zpwr_env.sh and overridable through a git-ignored .tokens.sh file — control everything from colorization to auto-listing behavior to banner display. This parametric architecture means ZPWR can be tuned without modifying source code, and personal customizations survive updates cleanly.
Above this foundation sits the verb system, the primary interface through which users interact with ZPWR's capabilities. Over 506 subcommands are registered in a central associative array (ZPWR_VERBS), each mapping a verb name to a function and a description. Typing zpwr followed by a tab presents a colorized menu of every available command, complete with grouped descriptions and neon-styled separators. This design prioritizes discoverability — a user need not memorize commands but can browse and search them interactively, aided by fzf-powered fuzzy finding via zpwr verbs.
The autoload system organizes 510 zsh functions across 14 subdirectories, separated by concern: common utilities, fzf integrations, completion functions, platform-specific logic for Darwin and Linux, and systemd management. These functions are lazily loaded, compiled to .zwc bytecode for performance, and automatically available when invoked. This approach mirrors the philosophy of modern plugin architectures while remaining rooted in zsh's native autoload mechanism.
ZPWR's plugin infrastructure is managed by zinit, a high-performance zsh plugin manager that replaced oh-my-zsh to achieve faster shell startup times. The system loads approximately 95 plugins, of which 30 or more are custom creations from the MenkeTechnologies organization. These custom plugins address gaps left by the broader zsh ecosystem — zsh-expand handles spelling correction, abbreviation expansion, and automatic capitalization; zsh-git-acp streamlines git add-commit-push workflows; zsh-more-completions contributes to the system's staggering total of over 14,100 tab completions.
Plugins are loaded conditionally based on operating system, available tools, and user preferences. Docker, Kubernetes, .NET, and OpenShift plugins appear only when their respective tools are installed. This conditional architecture prevents bloat while ensuring that ZPWR adapts to whatever environment it inhabits.
ZPWR treats vim and tmux not as separate tools but as extensions of the shell itself. The vim configuration spans nearly 2,000 lines and orchestrates 79 plugins including YouCompleteMe for intelligent completion, UltiSnips for snippet expansion, vim-airline for a decorated status line, and vim-autosave to eliminate the cognitive overhead of manual saves. A custom autohighlight system illuminates every occurrence of the word under the cursor, echoing the behavior of JetBrains IDEs within a terminal-native editor.
The integration between vim and tmux is where ZPWR's cockpit metaphor becomes most tangible. Keybindings allow users to execute the current file or visual selection directly in an adjacent tmux pane, with language-aware dispatch supporting shell, Python, Ruby, Perl, Clojure, Java, Crystal, Swift, Lua, Fortran, CoffeeScript, Lisp, Haskell, OCaml, Tcl, and Vimscript. The tmux layer itself supports layouts of 4, 8, 16, or even 32 panes, with REPL variants for interactive development. Platform-specific prefixes — Control-a on macOS, Control-b on Linux — enable seamless nested sessions when SSH-ing between machines.
fzf permeates ZPWR like electricity through a circuit board. File search with syntax-highlighted preview (zpwr vimfilesearch), content search with line-numbered results (zpwr vimwordsearch), network process inspection (zpwr lsof), and environment variable exploration all flow through fzf's fuzzy matching interface. Even archive files — JAR, WAR, deb, rpm, zip, and tgz — can be x-rayed through fzf-powered preview windows. The git repository cache system (zpwr gitrepos, zpwr gitreposdirty) allows users to discover and operate on all repositories on their system, broadcasting commands across them with zpwr gitreposexec.
This pervasive fuzzy finding transforms ZPWR from a configuration framework into something closer to an interactive knowledge base for one's own system. The user does not need to remember where things are; they need only begin typing.
ZPWR runs on an impressive breadth of platforms: macOS, Debian, Ubuntu, Fedora, CentOS, Alpine, Arch, Manjaro, Mint, Garuda, Pop!_OS, Kali, Parrot OS, Artix, ArcoLinux, Endeavour OS, Zorin, MX Linux, Oracle Linux, SUSE, Raspbian on Raspberry Pi, Rock64 single-board computers, FreeBSD, and multiple WSL distributions. The system achieves this breadth through OS-aware branching at every layer — different plugins, different tmux configurations, different package manager integrations, and different function libraries are loaded depending on the detected platform.
This is not mere lip service to portability. ZPWR's installer (zpwrInstall.sh) handles dependency installation across these platforms, backs up existing configurations with timestamped copies, and symlinks its own configurations into place. The result is that a user can clone ZPWR onto a fresh Arch installation or a corporate Ubuntu server and arrive at a familiar, fully-featured environment within minutes.
One of ZPWR's most distinctive features is its MySQL-backed learning database. Users can record commands, search their learning history with zpwr searchl, and generate SQL update statements with zpwr redo. This system transforms the shell from a stateless command executor into a persistent knowledge repository. Combined with frecency-based directory jumping (via z and fasd) and zpwr vimrecent for time-traveling through edit history, ZPWR builds an ever-deepening model of how its user works.
ZPWR's cyberpunk aesthetic is not mere decoration. The neon color coding serves a functional purpose: different completion groups — commands, aliases, keywords, builtins, parameters, files, history, corrections — are visually distinguished through color, allowing the eye to parse dense information quickly. The colored separators, ANSI-styled git output, and lolcat-piped banners create an environment that rewards attention and makes the act of using a terminal feel intentional rather than incidental.
The project embodies several core principles. Centralization keeps the system manageable and uninstallable. Discoverability ensures that the system's vast capabilities are surfaced rather than buried. Visual feedback makes state changes and information hierarchies immediately apparent. Customization with privacy allows deep personalization without exposing secrets to version control. Performance through compiled caches, lazy loading, and frecency algorithms ensures that the system's richness does not come at the cost of responsiveness. And extensibility through the verb system means users can grow ZPWR to match their own workflows.
ZPWR represents a particular vision of what computing can be: fast, visible, integrated, and deeply personal. In an era of electron-wrapped editors and cloud-dependent workflows, it insists that the terminal — the original interface between human and machine — remains the most powerful environment for those willing to invest in mastering it. With its 506 verbs, 14,100 completions, 2,000 aliases, and 50,000 lines of hand-forged code, ZPWR is less a configuration framework and more a manifesto rendered in shell script — a declaration that the command line is not a relic of the past but a cockpit for the future.
If your terminal isn't glowing, you're not running ZPWR.