Linux command: cd

Every time you move around a Linux system, you use cd. You type it to step into a project, to climb back out, and to jump across a server before you edit a config file or read a log. It feels like the simplest command there is: pick a folder, go there. Yet cd is not even a real program, and understanding why teaches you something deep about how Unix works.

2. Where the Name Comes From

The name cd is short for change directory.

cd  =  Change 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 letters: ls (list), cp (copy), mv (move), rm (remove), and cd (change directory).

Once a name is in everyone's muscle memory, there is no reason to change it. Fifty years later, cd is still cd on every Unix-like system in the world.

4. Simple Use Cases

4.1 The Simplest Possible Move

Give cd a path and it takes you there. In the examples below, the line that starts with $ is what you type; pwd ("print working directory") confirms where you landed.

$ cd /var/log
$ pwd
/var/log

Notice that cd prints nothing when it succeeds. Silence means success. This is the Unix habit of "no news is good news": a command only speaks up when something goes wrong.

4.2 Absolute and Relative Paths

You can point cd at a directory in two ways. An absolute path starts with a slash and describes the location from the root of the filesystem. A relative path does not start with a slash and is understood from where you are now.

$ cd /etc/nginx        # absolute: always the same place
$ cd sites-enabled     # relative: a folder inside where I already am

Relative paths are what make cd quick. If you are already in /etc/nginx, you type cd sites-enabled instead of the full path.

4.3 Going Up: ..

Every directory contains two special entries: . means "this directory" and .. means "the parent directory". You use .. constantly to climb back up.

$ cd ..            # up one level
$ cd ../..         # up two levels
$ cd ../sibling    # up one, then down into a neighbour folder

4.4 Going Home: cd With No Path

Type cd on its own, with nothing after it, and it takes you to your home directory. This is the value of the $HOME variable, usually /home/yourname.

$ cd
$ pwd
/home/peter

The tilde ~ is a shorthand for the same place, and it also works as part of a longer path:

$ cd ~             # home, same as bare cd
$ cd ~/Documents   # the Documents folder inside home
$ cd ~peter        # the home directory of the user "peter"

4.5 Jumping Back: cd -

This is the one that feels like magic once you know it. cd - takes you back to the directory you were in just before the last cd. It toggles between two places, like the "last channel" button on a remote.

$ pwd
/home/peter/project
$ cd /etc/nginx
$ cd -             # jump back
/home/peter/project
$ cd -             # and back again
/etc/nginx

Notice that cd - also prints the directory it moved to. It is the one form of cd that is not silent, because it is convenient to see where you landed. Behind the scenes, the shell remembers your previous directory in a variable called $OLDPWD, and cd - simply jumps to it.

6. Advanced Use Cases

6.1 Why cd Must Be a Shell Builtin

Here is the fact that makes cd genuinely interesting. Run these two commands:

$ type cd
cd is a shell builtin
$ which cd
$                       # prints nothing: there is no program called cd

There is no file /bin/cd or /usr/bin/cd to run. cd is built into the shell. The reason is one of the most important rules in Unix: a child process cannot change its parent's current directory.

When you run a normal program like ls, the shell starts it as a separate child process. That child gets its own copy of the current directory. If cd were a normal program, it would start as a child, change its own current directory, and then exit, and your shell (the parent) would not have moved an inch. The change would vanish with the child.

shell (your process)          current dir: /home/peter
   |
   +-- runs a program           gets a COPY of the current dir
        changes its own dir
        exits                    the copy is thrown away
   |
shell (your process)          current dir: STILL /home/peter

The only way to change the shell's own directory is to run the code inside the shell process, not in a child. That is exactly what a builtin is: a command the shell runs itself. So cd has to be a builtin. The same is true for anything that must change the shell's own state, such as export and umask.

Under the hood, the shell does the actual move through a single kernel system call named chdir() ("change directory"). The current working directory is not a shell invention; it is a property the kernel stores for every process. When you type cd /var/log, the shell calls chdir("/var/log"), and the kernel updates the shell process's own current directory. Because a child process inherits a copy of that directory but can never reach back into its parent, the builtin is the only place the call can usefully happen.

6.2 The Directory Stack: pushd, popd, dirs

Where cd - remembers one previous directory, the directory stack remembers a whole pile of them. pushd ("push directory") moves you to a new directory and saves your current one on top of a stack. popd ("pop directory") removes the top entry and takes you back to it. dirs shows the stack.

$ cd /usr
$ pushd /etc         # go to /etc, remember /usr
/etc /usr
$ pushd /var         # go to /var, remember /etc and /usr
/var /etc /usr
$ dirs -v            # show the stack, numbered
 0  /var
 1  /etc
 2  /usr
$ popd               # drop /var, go back to /etc
/etc /usr

This is how you take a quick detour without losing your place. You pushd into another directory, do a small job, and popd straight back to where you were. For a deep task with many jumps, the stack beats trying to remember paths by hand.

6.3 Logical Versus Physical: -L and -P

Symbolic links make one directory appear inside another. This raises a subtle question: when you cd through a symlink and then type cd .., where should "up" take you? Back the way you came, or up the real folder on disk?

By default, cd is logical (the -L option, short for logical): it remembers the path you typed, symlinks and all. The -P option (short for physical) makes cd resolve every symlink first, so you sit in the real directory on disk.

$ ln -s /var/www/html site   # "site" is a link to /var/www/html
$ cd site
$ pwd
/home/peter/site             # logical: the path you followed
$ pwd -P
/var/www/html                # physical: the real location

$ cd ..                      # logical: back to /home/peter
$ cd -P site && cd ..        # physical: up from /var/www/html to /var/www

Most of the time the logical default is what you want, because it matches how you got there. Reach for cd -P when you care about the true location on disk, for example in a script that must not be confused by a symlinked path.

8. Best Practices

• Learn cd - today. Toggling between two directories with cd - saves more keystrokes than almost any other trick. It is the first thing to make automatic.
• Use pushd and popd for detours. When you need to pop into another folder and come straight back, the directory stack keeps your place for you.
• Lean on Tab completion. Type a few letters and press Tab. It is faster and it prevents typos in long paths.
• Set CDPATH for folders you visit constantly, and always include . in the list so a nearby folder still wins.
• Use source, not execution, when a script must move your shell. A plain ./script.sh changes only the script's own directory.
• Reach for the documentation. Because cd is a builtin, its manual is inside the shell, not a separate page.

$ help cd           # the built-in help for cd (Bash)
$ help pushd        # and for the directory stack
$ man bash          # the full shell manual, with a SHELL BUILTINS section

Note that man cd usually says "No manual entry", precisely because cd is not a standalone program. Use help cd instead.

10. Summary

The cd command looks trivial, but it is a doorway into how Unix processes and the filesystem really work.

• cd means "change directory". It moves your shell's current working directory, the spot every other command works from.
• It cannot be an ordinary program, because a child process cannot change its parent's directory. That is why cd is a shell builtin.
• Bare cd goes home, cd .. goes up, cd - jumps back to the previous directory, and ~ is shorthand for home.
• CDPATH gives relative cd a search path; cdable_vars lets a variable name stand in for a folder.
• pushd, popd, and dirs manage a stack of directories for taking detours without losing your place.
• -L (logical, the default) follows the path you typed; -P (physical) resolves symlinks to the real location on disk.
• A cd inside a script only moves that script; use source to move your own shell.
• The help lives in the shell: help cd, not man cd.

This is the quick reference worth keeping:

cd DIR       go to a directory
cd           go to your home directory
cd ~/x       go to folder x inside home
cd ..        go up one level
cd -         jump back to the previous directory
pushd DIR    go there and save the old spot on the stack
popd         return to the last saved spot
dirs -v      show the directory stack, numbered
cd -P DIR    enter the real directory, resolving symlinks
help cd      the built-in manual

Small commands like cd hide a surprising amount of how Linux is built. 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 the fundamentals. That is exactly the kind of work I enjoy helping with.