Linux command: pwd

Every shell session starts you somewhere in the filesystem, and almost every command you run depends on where that "somewhere" is. pwd is the command that answers the simplest question in Linux: where am I right now? It looks like the most boring tool on the system, yet behind those three letters sits a small surprise about how the kernel really tracks your position, and why two versions of pwd can disagree about the very same directory.

2. Where the Name Comes From

The name pwd is short for print working directory.

pwd  =  Print Working Directory

Like most early Unix commands, it was made short on purpose. Early Unix was typed on slow teletype terminals that printed each character onto paper, so short names saved both time and ink. That is why so many core commands are two or three letters: ls (list), cp (copy), mv (move), cd (change directory), and pwd (print working directory).

The word "print" here means "print to the screen", which in the teletype era literally meant printing onto paper. Today it just writes one line to your terminal, but the name has never changed.

4. Simple Use Cases

4.1 The Simplest Possible Use

Type pwd with nothing after it. It prints one line: the full, absolute path of where you are. In the example below, the line that starts with $ is what you type, and the line under it is what the system prints back.

$ pwd
/home/peter/projects/website

The path always starts from the root / and is absolute, so it is never ambiguous. Wherever you paste that line, it means the same directory.

4.2 The First Thing to Type on a Strange Server

When you log in to an unfamiliar machine over SSH, or when a script has left you somewhere unexpected, pwd is the safe first move. It only reads; it changes nothing. Paired with ls and whoami, it answers the three questions that orient you instantly.

$ whoami
peter
$ pwd
/var/www/example.com
$ ls
config  logs  public_html

Together these say: I am the user peter, standing in the site's web root, and here is what it contains. Now you know it is safe to act.

4.3 The $PWD Variable

The shell also keeps your current directory in a variable called $PWD. Most of the time echo "$PWD" and pwd print the same thing.

$ echo "$PWD"
/home/peter/projects/website

The shell keeps a companion variable too: $OLDPWD holds the directory you were in before the last cd. It is the value that powers cd -, the "jump back" shortcut.

$ cd /etc
$ cd /var
$ echo "$OLDPWD"
/etc

The difference is that $PWD is a string the shell stores and trusts, while pwd can be asked to check the real filesystem. That gap is small, but it is exactly where the surprises in section 7 come from.

4.4 pwd Inside Your Prompt

You rarely type pwd as often as you might expect, because most shells already show a shortened form of the current directory in the prompt itself. In Bash the special code \w puts the working directory into your prompt string $PS1.

$ PS1='\u@\h:\w\$ '
peter@server:~/projects/website$

Here \w is the working directory (with your home shown as ~), \u is the user, and \h is the hostname. When your prompt already shows where you are, pwd becomes the tool you reach for inside scripts and when the prompt is hidden.

6. Advanced Use Cases

6.1 The Builtin and the Program Disagree

Here is the fact that trips up even experienced users. There are two pwd commands, and their defaults are opposite. Confirm it for yourself:

$ type pwd
pwd is a shell builtin
$ which pwd
/bin/pwd

When you type pwd, you get the shell builtin, whose default is logical (-L). The separate program at /bin/pwd, from GNU coreutils, defaults to physical (-P). Stand in a symlinked directory and the two print different paths for the same spot:

$ cd /home/peter/site          # a symlink to /var/www/html
$ pwd                          # the builtin: logical by default
/home/peter/site
$ /bin/pwd                     # the program: physical by default
/var/www/html

Neither is wrong; they answer different questions. But if a script calls /bin/pwd expecting the same output as an interactive pwd, the mismatch can cause real, hard-to-find bugs. When it matters, be explicit and always pass -L or -P yourself instead of relying on the default.

6.2 How pwd Finds the Path at All

Recall the mental model from section 1: the kernel stores your position as a pointer to a directory, not as a string. So how does a physical pwd turn that pointer back into text like /var/www/html?

The classic method is to walk up the tree. Every directory contains an entry called .. that points to its parent. Starting from where you are, pwd looks at the parent, finds the name that leads back to the current directory, remembers it, then repeats one level higher, all the way to the root /. Reversing that list of names gives the full path.

current dir  --  ..  -->  parent    (find my name here: "html")
parent       --  ..  -->  /var/www  (find its name: "www")
/var/www     --  ..  -->  /var      (find its name: "var")
/var         --  ..  -->  /         (reached the root)

read the names in reverse:  / + var + www + html  =  /var/www/html

Modern Linux makes this fast with a single system call, getcwd(), so the shell rarely walks the tree by hand any more. But the old idea still explains the behaviour, especially the failure you will see in the next section. The logical builtin skips all of this: it just prints the string it has been keeping in $PWD, which is why it is instant and why it can sometimes be out of date.

The same getcwd() call is what every programming language reaches for under the hood. This is why "print the working directory" looks almost identical whatever tool you use:

char *getcwd(char *buf, size_t size);   // C, the underlying call
os.getcwd()                             # Python
getcwd();                               // PHP

The command pwd is really just a thin wrapper around this one kernel service.

6.3 Keeping $PWD and Reality in Sync

Because the logical answer comes from a stored string, it is only correct as long as the shell keeps that string up to date. The shell does this for you every time you use cd. Trouble appears when something moves the directory underneath you without the shell knowing, which is exactly the case in the next section.

8. Best Practices

• Run pwd the moment you feel lost. On a strange server, or when a command behaves oddly, confirm where you are before you act. It is read-only and cannot break anything.
• Be explicit about -L and -P when it matters. Do not rely on the default in scripts. If you need the real location, write pwd -P; if you need the path as navigated, write pwd -L.
• Remember that pwd and /bin/pwd default differently. The builtin is logical, the coreutils program is physical. A script that mixes them can compare two paths that were never meant to match.
• Capture the path with "$(pwd)", always quoted. Quoting protects paths that contain spaces, which are common on real systems.
• If pwd looks stale, just cd again. After a directory is moved or removed under you, a fresh cd to a real path resets $PWD.
• Reach for the documentation. Because there are two versions, they document in two places.

$ help pwd            # the built-in version (Bash)
$ man pwd             # the coreutils program at /bin/pwd
$ pwd --help          # a quick option summary from the program

Note that help pwd describes the builtin your shell actually runs, while man pwd describes /bin/pwd. When their behaviour differs, read the one that matches the command you are calling.

10. Summary

The pwd command looks trivial, but it is a clear window into how Linux tracks your place in the filesystem.

• pwd means "print working directory". It prints the absolute path of the folder your shell is standing in.
• The current directory is per process and is stored by the kernel as a pointer to a directory, not as a piece of text. pwd turns that pointer back into a readable path.
• -L (logical, the default builtin) shows the path as you navigated it, symlinks kept. -P (physical) resolves symlinks to the real location.
• There are two versions: the shell builtin (logical by default) and /bin/pwd from coreutils (physical by default). Their defaults are opposite.
• The logical answer comes from the $PWD string, so it can be stale; the physical answer is rebuilt from the filesystem and fails if the directory has been removed.
• If a folder is moved or deleted under you, pwd can show an old name. A fresh cd fixes it.
• Documentation lives in two places: help pwd for the builtin, man pwd for the program.

This is the quick reference worth keeping:

pwd          print the current directory (logical, as navigated)
pwd -L       force the logical path (keep symlinks)
pwd -P       force the physical path (resolve symlinks)
/bin/pwd     the coreutils program (physical by default)
echo "$PWD"  the shell's stored copy of the path
here=$(pwd)  capture the path into a variable
help pwd     built-in manual (Bash)
man pwd      manual for /bin/pwd

Small commands like pwd hide a surprising amount of how Linux is built, from per-process state to the difference between a name and a real location on disk. If your servers behave in ways that are hard to explain, or you want a setup that is easier to run day to day, it often pays to look closely at these fundamentals. That is exactly the kind of work I enjoy helping with.