which Command on Mac: The zsh Built-in vs /usr/bin/which

On macOS 26.4.1, this is what a missing command looks like when you capture which in zsh:

% out=$(which nosuchcmd)
% echo "rc=$? captured=[$out]"
rc=1 captured=[nosuchcmd not found]

The exit status is 1, but the variable isn't empty. It holds the error text, because the which you get in Terminal is a zsh built-in, and it prints "not found" on standard output. So a test like [ -n "$(which foo)" ] is true whether or not foo exists. Put the same line in a #!/bin/bash script and it behaves the other way, because bash on a Mac has no built-in which and runs /usr/bin/which, which prints nothing: the same line in bash 3.2 gives rc=1 captured=[].

The which command on Mac is two different programs depending on which shell runs it, and they disagree on output, on the -s flag, on built-ins, and on what they report after you install something new. I ran each case on a Mac mini M4 with zsh 5.9 and Apple's /usr/bin/which, read Apple's source for the binary, and counted how often my own shell commands ran into it.

Which which you're running

zsh has been the default login shell since macOS Catalina, and its which is a built-in. The zsh manual defines it in three words: "Equivalent to whence -c". The binary at /usr/bin/which is a separate thing. Running what /usr/bin/which on this Mac prints PROJECT:shell_cmds-329, and the matching which.c in Apple's published source is 147 lines: it splits PATH, checks each directory for a regular file with an execute bit, and prints the first hit. It knows nothing about aliases, functions, built-ins or the shell's command cache.

Where you type it	What runs
Terminal (zsh, the default)	zsh built-in which = whence -c
#!/bin/zsh script	zsh built-in
#!/bin/bash or #!/bin/sh script	/usr/bin/which (bash 3.2 reports which is /usr/bin/which; /bin/sh runs bash here)
A coding agent's shell tool, Makefile $(shell ...), cron	Whatever shell that tool starts. Claude Code on this Mac runs commands through zsh

Difference 1: "not found" goes to stdout

Here's every common lookup form, run against a command that doesn't exist and one that does:

Command	zsh output (missing)	Exit	/usr/bin/which
which nosuch	nosuch not found on stdout	1	nothing, exit 1
which -s nosuch	nosuch not found	1	nothing, exit 1
which ls nosuch cat	/bin/ls, nosuch not found, /bin/cat	1	/bin/ls, /bin/cat, exit 1
type nosuch	nosuch not found on stdout	1	n/a
command -v nosuch	nothing	1	n/a
whence -p nosuch	nothing	1	n/a

The exit status is right in every case. Only the output is a trap, and 2>/dev/null doesn't help, because the message isn't on stderr. I checked my own history for this. Across 3,098 Claude Code transcripts on this machine (16,398 Bash tool calls, excluding this session and probe runs), 233 commands ran which as a command. Fifteen of them either captured it with $(which ...) or added 2>/dev/null to silence misses, and in five of those fifteen the result still contained lines like mutool not found and qpdf not found. Those were tool checks, so the noise was harmless. One capture was not harmless in principle: B=$(which llama-server 2>/dev/null) followed by otool -L $B. The binary was installed that day; without it, $B would have been the three words llama-server not found.

Difference 2: -s means the opposite

man which on a Mac documents Apple's binary, where -s means "No output, just return 0 if all of the executables are found". In zsh, -s is a whence option that prints the symlink chain:

% which -s git
/opt/homebrew/bin/git -> /opt/homebrew/Cellar/git/2.54.0/bin/git
% /usr/bin/which -s git; echo $?
0

So if which -s brew; then, copied from a man page into a zsh script, prints a path into your output on every run. The exit codes match, which is why it usually goes unnoticed.

Difference 3: built-ins, aliases and functions

% which cd
cd: shell built-in command
% /usr/bin/which cd
/usr/bin/cd
% alias ll='ls -l'; which ll
ll: aliased to ls -l
% /usr/bin/which ll; echo $?
1

macOS ships a /usr/bin/cd shell script for POSIX reasons, and Apple's which finds it, though cd in your shell never runs it. For a function, zsh's which prints the entire function body, which is useful interactively and useless to a script expecting one line.

Difference 4: what runs versus what's first in PATH

This is the one that matters after brew install. Shells cache the path of each command the first time they run it. I set up two directories with a script named foo in each, with the first directory empty to start, ran foo once (so the shell cached the second copy), then created foo in the first directory, ahead of it in PATH:

Check	zsh says	bash says
Typing foo runs	b (prints B)	b (prints B)
which foo	b	a (wrong about what runs)
type foo	b	foo is hashed (.../b/foo)
which -a foo / type -a foo	a, then b	a, then b
/usr/bin/which foo	a	a
After hash -r	runs a	runs a

In zsh, plain which is honest about what the shell will run. The -a forms and Apple's binary describe PATH order, which is what a new shell will run. That's the classic "which git says Homebrew but git --version says Apple Git" situation, and it means advice like "the first line of type -a is what your shell runs" holds only in a fresh shell or after hash -r. The reverse case is handled: when I deleted the cached copy instead, zsh noticed and both which and the next run went to the remaining one, while bash failed with No such file or directory and exit 127 until hash -r.

What to use instead

For scripts, command -v is the form that behaves the same way in zsh, bash and /bin/sh: silent and exit 1 when the name is missing, one line when it's found. The long Unix & Linux thread on why not to use which (512 votes, about 102,000 views as of 2026-10-16) reaches the same answer for portability reasons; on a Mac the zsh output quirk is a more immediate one.

# existence check, any shell
if command -v gsort >/dev/null; then sort=gsort; else sort=sort; fi

# capture a path, empty when missing
bin=$(command -v llama-server) || { echo "llama-server not installed" >&2; exit 1; }

# after brew install, in the same terminal
hash -r          # or: rehash (zsh)
type -a git      # now the first line is what runs

One limit: for an alias, command -v prints the alias definition, and for a built-in it prints just the name (cd), so if you need a file path specifically, use whence -p in zsh or check that the result starts with /. If you rely on GNU tools under their own names, the same "which copy runs" question decides whether realpath is Apple's or GNU's; I covered that in realpath on Mac. The update guides for updating git on Mac and updating Vim on Mac depend on it too, and errors such as zsh: killed on Mac are easier to chase once you know which binary actually ran.

FAQ

Why does which print "not found" in my script output on Mac?

Because the script runs under zsh, where which is a built-in (equivalent to whence -c) that writes "name not found" to standard output and exits 1. Redirecting stderr with 2>/dev/null doesn't hide it. Use command -v name >/dev/null, which prints nothing for a missing command in zsh, bash and /bin/sh, and test its exit status instead of its output.

What does which -s do on Mac?

It depends on the shell. Apple's /usr/bin/which, used by bash and /bin/sh scripts and documented in man which, treats -s as silent: no output, exit 0 if every name is found. The zsh built-in that Terminal uses treats -s as "show symlinks" and prints the resolved chain, for example /opt/homebrew/bin/git -> /opt/homebrew/Cellar/git/2.54.0/bin/git. Run /usr/bin/which -s explicitly if you want the silent form.

Why does which show the Homebrew path but the old version still runs?

The shell cached the old path the first time you ran the command. /usr/bin/which, which -a and type -a list PATH order, which is what a new shell would run, but the current shell keeps using the cached path. Run hash -r (or rehash in zsh), or open a new terminal. In zsh, plain which and type without -a show the cached path that will actually run.

How this was checked: every command ran on 2026-10-16 on a Mac mini M4 with macOS 26.4.1, zsh 5.9 started with zsh -f (no startup files) and Apple's bash 3.2.57, against /usr/bin/which from shell_cmds-329 as reported by what(1). The cache test used two throwaway directories in a work folder with a two-line shell script in each, not real Homebrew installs. Source lines come from Apple's published shell_cmds-329 which.c and the zsh 5.9 manual. The transcript figures are a regex over Bash tool calls in this machine's Claude Code transcripts, excluding this session and probe sessions; "ran which as a command" means which at the start of a command, after a separator, or inside $( ), so it can miss unusual forms. The Stack Exchange vote and view counts were read from the Stack Exchange API the same day.