thelinuxvault blog

Linux Hard Link vs. Soft Link: Understanding the Differences

In the Linux filesystem, links are powerful tools that allow you to reference files and directories in flexible ways. They help organize data, save disk space, and simplify access to frequently used files. However, Linux offers two distinct types of links—hard links and soft links (symbolic links)—each with unique behaviors and use cases. Understanding their differences is critical for effective filesystem management, whether you’re a system administrator, developer, or casual Linux user.

This blog will demystify hard and soft links, explaining their underlying mechanics, key differences, practical applications, and common pitfalls. By the end, you’ll know when to use each type and how to work with them confidently.

2026-02

Table of Contents#

  1. What Are Links in Linux?
  2. Hard Links: Deep Dive
  3. Soft Links (Symbolic Links): Deep Dive
  4. Hard Link vs. Soft Link: Key Differences
  5. When to Use Hard Links vs. Soft Links
  6. Common Commands for Managing Links
  7. Troubleshooting Links: Dangling Symlinks & More
  8. Conclusion
  9. References

At their core, links are pointers that reference files or directories in the filesystem. They act as "shortcuts" but with nuanced behaviors depending on the link type. Links help:

  • Avoid redundant copies of large files (saving disk space).
  • Simplify access to files/directories buried deep in the filesystem.
  • Maintain backward compatibility (e.g., linking legacy paths to new locations).

Linux supports two primary link types: hard links and soft links (symbolic links). The key distinction lies in how they reference the target file/directory—via the filesystem’s underlying metadata (inodes) or via a path.

Definition & Inode Basics#

A hard link is a direct reference to the inode of a file. To understand hard links, you first need to grasp what an inode is:

  • Inode: A data structure in Linux filesystems that stores metadata about a file, such as its size, permissions, creation/modification times, and pointers to the actual data on disk. Filenames are not stored in inodes; instead, they are human-readable labels that map to inodes.

A hard link is simply another filename that points to the same inode as the original file. In other words, the original file and its hard link are indistinguishable at the inode level—they are two names for the same data.

Hard links have strict limitations and unique behaviors:

  1. Shared Inode: Hard links share the same inode as the original file. Use ls -i to verify (same inode number = same file data).
  2. Link Count: The inode tracks how many hard links point to it (the "link count"). Creating a hard link increases this count by 1; deleting a link decreases it by 1. The file’s data is only deleted when the link count reaches 0.
  3. No Directories: Hard links cannot reference directories. Linux prohibits this to avoid filesystem cycles (e.g., a directory linking to itself), which would break tools like ls -R or find.
  4. Same Filesystem Only: Hard links are restricted to the same filesystem (partition). This is because inode numbers are unique only within a filesystem, not across multiple disks/partitions.
  5. Resilient to Renaming: If the original file is renamed, the hard link remains functional. Renaming only changes the filename, not the inode.
  6. No "Broken" State: Hard links cannot become "broken" because they reference the inode directly. Even if the original filename is deleted, the hard link remains accessible until all links to the inode are removed.

Use the ln command (without flags) to create a hard link:

ln [original-file] [hard-link-name]

Let’s walk through a practical example:

  1. Create an original file:

    echo "Hello, Hard Links!" > original.txt

  2. Create a hard link named link_hard.txt:

    ln original.txt link_hard.txt

  3. Verify inode and link count:
    Use ls -li to check inode numbers and link counts (the second column):

    ls -li original.txt link_hard.txt

    Output:

    12345 -rw-r--r-- 2 user user 20 Jun 1 10:00 original.txt
12345 -rw-r--r-- 2 user user 20 Jun 1 10:00 link_hard.txt
    • Both files share the same inode (12345).
    • The link count is 2 (original + hard link).

  4. Modify the original file:
    Changes to either the original or hard link affect both, since they share the same data:

    echo "Updated content" >> original.txt
cat link_hard.txt  # Output: "Hello, Hard Links! Updated content"

  5. Delete the original file:
    The hard link remains accessible:

    rm original.txt
cat link_hard.txt  # Still outputs: "Hello, Hard Links! Updated content"

  6. Check link count after deletion:
    The link count drops to 1 (only the hard link remains):

    ls -li link_hard.txt

    Output:

    12345 -rw-r--r-- 1 user user 35 Jun 1 10:05 link_hard.txt

Definition & How They Work#

A soft link (or "symbolic link," often called a "symlink") is a special file that contains the path to the original file or directory. Unlike hard links, symlinks do not reference the inode directly—they act as pointers to the target’s filesystem path.

Soft links have distinct characteristics that set them apart from hard links:

  1. Own Inode: Symlinks have their own inode and metadata (e.g., permissions, size). The inode stores the path to the target, not the target’s data.
  2. Link Count Unchanged: Creating a symlink does not affect the target’s link count. The symlink is treated as a separate file.
  3. Supports Directories: Symlinks can reference directories, making them ideal for organizing nested filesystems (e.g., linking /var/www to /home/user/website).
  4. Cross-Filesystem: Symlinks work across different filesystems (e.g., linking a file on /dev/sda1 to /dev/sdb1).
  5. Fragile to Path Changes: If the target file is renamed, moved, or deleted, the symlink becomes "dangling" (broken), as it points to a non-existent path.
  6. Visible as Links: Tools like ls -l explicitly mark symlinks with an l in the permission column and show the target path (e.g., link_soft.txt -> original.txt).

Use ln -s to create a symbolic link:

ln -s [original-file-or-directory] [soft-link-name]

Let’s demonstrate soft link behavior:

  1. Create an original file:

    echo "Hello, Soft Links!" > original.txt

  2. Create a soft link named link_soft.txt:

    ln -s original.txt link_soft.txt

  3. Verify the symlink:
    Use ls -l to check the symlink:

    ls -l link_soft.txt

    Output:

    lrwxrwxrwx 1 user user 12 Jun 1 11:00 link_soft.txt -> original.txt
    • The l in the permission column indicates a symlink.
    • The target path (original.txt) is shown after ->.

  4. Check inode (different from target):

    ls -li original.txt link_soft.txt

    Output:

    12345 -rw-r--r-- 1 user user 20 Jun 1 11:00 original.txt
67890 lrwxrwxrwx 1 user user 12 Jun 1 11:00 link_soft.txt -> original.txt

    The symlink has its own inode (67890).

  5. Delete the original file:
    The symlink becomes dangling (broken):

    rm original.txt
cat link_soft.txt

    Output:

    cat: link_soft.txt: No such file or directory

  6. Fix a dangling symlink:
    Recreate the target file, and the symlink will work again:

    echo "Restored original!" > original.txt
cat link_soft.txt  # Output: "Restored original!"

The table below summarizes the critical distinctions:

FeatureHard LinkSoft Link (Symbolic Link)
DefinitionAnother name for the same inode.Pointer to the target’s filesystem path.
InodeShares the target’s inode.Has its own inode.
Link CountIncreases target’s link count by 1.No effect on target’s link count.
Target TypesOnly files (not directories).Files or directories.
Cross-FilesystemNo (same filesystem only).Yes (works across partitions/disks).
Dangling StateCannot become dangling.Becomes dangling if target is deleted/moved.
Resilience to RenamingSurvives renaming of target.Breaks if target is renamed/moved.
SizeSame as target (shares data).Small (stores target path, ~dozens of byte).
PermissionsInherits target’s permissions (via inode).Own permissions (but target’s permissions apply when accessing).
  • Saving Space: Avoid duplicating large files (e.g., backups of log files on the same filesystem).
  • Guaranteeing Access: Ensure the file remains accessible even if the original filename is deleted.
  • Stability: The target will never be moved or renamed, and you need a permanent reference.
  • Linking Directories: Organize files (e.g., ln -s /home/user/docs /var/docs).
  • Cross-Filesystem Access: Link files across partitions (e.g., a file on an external drive).
  • Temporary Shortcuts: Create flexible pointers (e.g., linking a project’s latest.log to a daily log file).
  • Legacy Compatibility: Maintain old paths for scripts/tools while migrating files to new locations.
TaskCommand
Create a hard linkln original.txt link_hard.txt
Create a soft linkln -s original.txt link_soft.txt
Identify links in ls outputls -l (look for l in permissions column).
Check inode numbersls -i [file]
Read a symlink’s target pathreadlink link_soft.txt
Find all hard links to a filefind /path/to/search -samefile original.txt
Find dangling symlinksfind /path/to/search -xtype l

A dangling symlink points to a non-existent target. To fix this:

  1. Identify the broken link with ls -l (target path will be highlighted in red or marked as "deleted").
  2. Recreate the symlink with the correct target path: 
    ln -sf /new/path/to/target link_soft.txt  # -f overwrites the old symlink

Symlinks can use relative or absolute paths:

  • Absolute Path: ln -s /home/user/file.txt link.txt (resilient if the symlink is moved).
  • Relative Path: ln -s ../file.txt link.txt (relative to the symlink’s location, not the current directory).

Pitfall: Moving a symlink with a relative path breaks it. Use absolute paths for stability.

Permission Issues#

Symlink permissions are mostly irrelevant—accessing the target requires permissions on the target itself, not the symlink. For example, a symlink with 777 permissions won’t grant access to a target with 600 permissions.

Conclusion#

Hard and soft links are indispensable tools in Linux, each with unique strengths. Hard links offer stability and space efficiency on a single filesystem, while soft links provide flexibility for directories, cross-filesystem access, and temporary shortcuts. By understanding their mechanics and tradeoffs, you can optimize filesystem organization, avoid data loss, and troubleshoot issues like dangling symlinks.

Next time you need a "shortcut," ask: Do I need a permanent inode reference (hard link) or a flexible path pointer (soft link)? The answer will guide you to the right choice.

References#