What Does Pwd Do In Linux

Typing `pwd` in Linux prints the absolute path of the directory you are currently in. If you’ve ever wondered “what does pwd do in linux,” the answer is simple: it tells you exactly where you are in the file system. This command is one of the most basic yet essential tools for navigating Linux.

When you open a terminal, you start in a specific directory, usually your home folder. Over time, you might move around using `cd`, and it’s easy to lose track. That’s where `pwd` steps in—it stands for “print working directory.” It outputs the full path from the root (`/`) to your current location.

Think of it as a GPS for your terminal. Without it, you’d be guessing where files are saved or where commands will run. This article breaks down everything you need to know about `pwd`, from basic usage to advanced tricks.

The command `pwd` does exactly one thing: it prints the absolute path of the current working directory. An absolute path starts from the root directory (`/`) and includes every folder down to your current one. For example, if you’re in the “Documents” folder inside your home directory, `pwd` might output `/home/username/Documents`.

This is different from a relative path, which starts from your current location. Absolute paths are always the same, no matter where you are. That makes `pwd` reliable for scripts or when you need to share your exact location with someone else.

There are no options or flags that change the output significantly. The command is straightforward: type it, press Enter, and see your path. It’s part of the GNU Core Utilities, so it’s available on every Linux distribution by default.

Why The Name “Pwd”

The name comes from “print working directory.” In early Unix systems, commands were kept short to save typing. “Pwd” is just three letters, easy to remember and fast to type. The “print” part doesn’t mean a physical printer—it means display on the screen.

Some people confuse it with “password,” but that’s a different command (`passwd`). The lowercase “pwd” always refers to the directory command. Once you use it a few times, it becomes second nature.

How To Use Pwd In The Terminal

Using `pwd` is as simple as it gets. Open your terminal and type:

pwd

Press Enter. The terminal will show something like:

/home/john

That’s your current directory. You can run it anytime, anywhere. It works in scripts too. For example, if you write a bash script and need to know where the script is running, you can use `pwd` inside the script.

Here’s a quick example:

Open a terminal.
Type `cd /tmp` to move to the temp directory.
Type `pwd`. You’ll see `/tmp`.
Type `cd /var/log`.
Type `pwd` again. Now it shows `/var/log`.

Each time you run `pwd`, it reflects your current location. There’s no state to remember—it always gives the latest path.

Common Use Cases For Pwd

You’ll find `pwd` useful in many everyday situations. Here are a few:

Confirming your location after moving around with `cd`.
Debugging scripts that rely on file paths.
Sharing your path with a colleague or in documentation.
Checking if a symbolic link changed your directory (more on that later).
Using it in shell prompts to always see where you are.

Many users set their terminal prompt to show the current directory automatically. But even then, `pwd` is handy when the prompt gets truncated or when you need the full path for copying.

Understanding Absolute Vs Relative Paths

To fully grasp what `pwd` does, you need to understand paths. An absolute path starts with a slash (`/`), like `/home/user/projects`. It never changes based on your current directory. A relative path does not start with a slash, like `projects` or `../documents`.

When you use `pwd`, you always get an absolute path. This is crucial because relative paths can be ambiguous. For example, if you’re in `/home/user` and type `cd projects`, you go to `/home/user/projects`. But if you’re in `/tmp`, the same command would fail because `projects` doesn’t exist there.

Absolute paths remove that confusion. They are the canonical way to refer to a location. Scripts and configuration files often use absolute paths to avoid errors.

How Pwd Handles Symbolic Links

Symbolic links (symlinks) are shortcuts to other directories. If you `cd` into a symlink, your current directory might be the link itself, not the target. By default, `pwd` shows the logical path, which includes the symlink name.

For example, if you have a symlink `/home/user/link` pointing to `/var/www`, and you `cd` into it, `pwd` might show `/home/user/link`. But the actual physical directory is `/var/www`.

To see the physical path (resolving symlinks), use the `-P` flag:

pwd -P

This shows the real directory, ignoring symlinks. The `-L` flag (logical) is the default and shows the path as you entered it. Most of the time, the default is fine, but `-P` is useful when you need the true location.

Using Pwd In Scripts

Scripts often need to know where they are running. You can capture the output of `pwd` into a variable:

current_dir=$(pwd)
echo "You are in $current_dir"

This is common in bash scripts for logging or file operations. For example, if you want to save a file relative to the script’s location, you can use:

script_dir=$(dirname "$(realpath "$0")")
cd "$script_dir"

But `pwd` alone works if you just need the current directory at a specific moment. Be careful: if your script changes directories, `pwd` will reflect the new location.

Common Mistakes And Pitfalls

Even a simple command like `pwd` can trip you up. Here are some common errors:

Typing “pwd” as “pwd” but with a typo like “pwd” instead of “pwd” (that’s actually correct, but some people type “pwd” as “pwd” and wonder why it fails).
Forgetting that `pwd` shows the logical path when you’re inside a symlink. Use `-P` if you need the physical path.
Assuming `pwd` works in a subshell the same way. In a subshell, `pwd` shows the directory of that subshell, which might be different.
Not using `pwd` in scripts when you need absolute paths. Relative paths can break if the script is called from a different directory.

Another mistake is confusing `pwd` with `$PWD`. The environment variable `$PWD` holds the current directory. It’s set by the shell and updates automatically. You can use `echo $PWD` to see it. But `pwd` is a command, not a variable. Both give the same result in most cases, but `pwd` is more portable across shells.

Pwd Vs $PWD

Let’s clarify the difference. `pwd` is a built-in command (or an external program) that prints the directory. `$PWD` is an environment variable that stores the same information. They usually match, but there are edge cases.

For example, if you change directories in a script without using `cd` (like using `pushd` and `popd`), `$PWD` might not update immediately. The `pwd` command always reflects the actual current directory as the kernel sees it.

In practice, use `pwd` for reliability. If you need the path in a string, you can use `$PWD` for convenience, but be aware of potential inconsistencies.

Advanced Pwd Techniques

While `pwd` is simple, you can combine it with other commands for powerful results. Here are a few advanced uses:

Getting The Parent Directory

You can get the parent of the current directory using `dirname`:

dirname $(pwd)

This outputs the folder above your current one. For example, if you’re in `/home/user/projects`, it shows `/home/user`.

Checking If A Directory Exists

You can use `pwd` in conditional statements. For example, to check if you’re in a specific directory:

if [ "$(pwd)" = "/home/user" ]; then
    echo "You are in the home directory"
fi

This is useful in scripts that should only run from certain locations.

Using Pwd With Find

The `find` command often needs absolute paths. You can combine it with `pwd` to search from your current location:

find "$(pwd)" -name "*.txt"

This searches for all text files starting from your current directory, using the full path. Without `pwd`, `find` would use relative paths, which might not be what you want.

Pwd In Aliases

You can create aliases that use `pwd`. For example, to create a command that lists files in the current directory with full paths:

alias lsp='ls -l "$(pwd)"'

Then typing `lsp` lists all files with their absolute paths. This is handy for copying file locations.

Troubleshooting Pwd Issues

Sometimes `pwd` doesn’t behave as expected. Here are common issues and fixes:

Pwd shows a different path than expected: You might be in a symlink. Use `pwd -P` to see the real path.
Pwd returns nothing: This is rare. Check if the shell is corrupted or if you’re in a weird state. Try `cd /` then `pwd`.
Pwd shows “Permission denied”: This shouldn’t happen for `pwd` itself, but if the directory is inaccessible, the kernel might refuse. Usually, you can’t `cd` into such directories anyway.
Pwd in a script gives wrong path: The script might have changed directories. Use `pwd` at the point you need it, not earlier.

If you’re using a non-standard shell, `pwd` might be an external command instead of a built-in. Check with `type pwd`. If it says “pwd is /bin/pwd”, it’s external. Built-in versions are faster.

Pwd In Different Shells

Most shells (bash, zsh, sh, ksh) have `pwd` as a built-in. But they might behave slightly differently. For example, in bash, `pwd -P` always shows the physical path. In zsh, the default might be different depending on options.

If you’re writing a portable script, use the external `/bin/pwd` command to ensure consistency. But for everyday use, the built-in is fine.

Frequently Asked Questions

Here are common questions about `pwd` in Linux:

What does pwd stand for in Linux?

Pwd stands for “print working directory.” It prints the absolute path of your current location in the file system.

How do I use pwd to find my current directory?

Simply type `pwd` in the terminal and press Enter. It will output the full path, like `/home/username/folder`.

What is the difference between pwd and $PWD?

`pwd` is a command that prints the directory. `$PWD` is an environment variable holding the same value. They usually match, but `pwd` is more reliable in scripts.

Can pwd show the physical path instead of logical?

Yes, use `pwd -P` to show the physical path, resolving any symbolic links. The default `pwd` shows the logical path.

Is pwd available on all Linux distributions?

Yes, `pwd` is part of the GNU Core Utilities and is included in every Linux distribution. It’s also available on Unix-like systems like macOS.

Practical Examples To Try

Let’s put your knowledge into practice. Open your terminal and try these:

Type `pwd` to see your home directory.
Create a temporary directory: `mkdir /tmp/test_pwd`.
Change to it: `cd /tmp/test_pwd`.
Type `pwd` to confirm you’re there.
Create a symlink: `ln -s /tmp/test_pwd ~/mylink`.
Change to the symlink: `cd ~/mylink`.
Type `pwd` (logical) and `pwd -P` (physical) to see the difference.
Clean up: `rm ~/mylink` and `rmdir /tmp/test_pwd`.

These steps show how `pwd` behaves with symlinks. You’ll see that the logical path includes the link name, while the physical path shows the real directory.

Using Pwd With Other Commands

Combine `pwd` with `echo` to create a custom prompt. For example, you can add this to your `.bashrc`:

export PS1='[\u@\h \w]$ '

The `\w` shows the current directory. But if you want the full path always, use `\W` for just the basename. Experiment to find what works for you.

Another combo: `pwd | xargs ls` lists files in the current directory with full paths. But `ls -d “$(pwd)”/*` does the same more directly.

Conclusion

So, what does pwd do in linux? It prints your current working directory’s absolute path. This simple command is a cornerstone of terminal navigation. Whether you’re a beginner or a seasoned sysadmin, you’ll use `pwd` daily.

Remember the key points: use `pwd` to confirm your location, use `pwd -P` for physical paths, and use it in scripts for reliability. Avoid common mistakes like confusing it with `$PWD` or forgetting about symlinks.

Now you have a solid understanding of `pwd`. Go ahead and practice in your terminal. The more you use it, the more natural it becomes. Happy navigating!