How to Install and Use the ‘ldd’ Command in Linux

How to Install and Use the ‘ldd’ Command in Linux

Digital illustration of a Linux terminal depicting the installation of the ldd command used for checking dynamic dependencies of executable files

Are you looking to install the ldd command on your Linux system but finding it a bit complex? Sometimes the installation of Linux commands may seem daunting, however, ldd is worth learning to install and use. It enhances your understanding of library dependencies in Linux, making it easier to manage your system. It’s also readily available on most package management systems, simplifying the installation process once you understand it.

In this guide, we will navigate the process of installing the ldd command on your Linux system. We will provide you with installation instructions for APT-based distributions like Debian and Ubuntu, and YUM-based distributions like CentOS and AlmaLinux. We’ll delve into advanced topics like compiling from source, installing a specific version, and finally, we’ll guide you on how to use the ldd command and verify that the correct version is installed.

Let’s get started with the step-by-step ldd installation on your Linux system!

TL;DR: How Do I Install and Use the ‘ldd’ Command in Linux?

In most Linux distributions, the ‘ldd’ command comes pre-installed, you can verify this with the command, which ldd. If it isn’t installed, you can add it with the commands, sudo yum install glibc-common or sudo apt-get install libc6-dev. The command to use depends on your Linux environment. To use ‘ldd’, simply type ldd followed by the name of the binary file you want to check, ldd /path/to/file.

For example:

ldd /bin/ls

# Output:
# (0x00007ffcc35db000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e8b4000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e4c3000)
# /lib64/ (0x00007f1a8ed00000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e251000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e04d000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8de2e000)

This command will display the shared libraries needed by the /bin/ls program. The output shows the library name, its location, and the memory address where it is loaded.

This is just a basic way to use the ldd command in Linux, but there’s much more to learn about installing and using ldd. Continue reading for more detailed information and advanced usage scenarios.

Understanding and Installing the ‘ldd’ Command in Linux

The ldd command in Linux is a handy tool that displays the shared libraries required by each program. It’s a crucial command for developers and system administrators, as it helps in debugging and managing system dependencies.

Installing ‘ldd’ Command with APT

If you’re using a Debian-based Linux distribution such as Ubuntu, you can install the ldd command using the Advanced Packaging Tool (APT). In most cases, ldd comes pre-installed, but you can ensure it’s installed by running the following command:

sudo apt-get update
sudo apt-get install libc6-dev

# Output:
# Reading package lists... Done
# Building dependency tree
# Reading state information... Done
# ... (other output trimmed for brevity)

This command updates your package list and installs the libc6-dev package, which includes the ldd command.

Installing ‘ldd’ Command with YUM

If you’re using a Red Hat-based Linux distribution such as CentOS, you can use the Yellowdog Updater, Modified (YUM) to install ldd. The command is included in the glibc-common package. To install it, run the following command:

sudo yum install glibc-common

# Output:
# Loaded plugins: fastestmirror, langpacks
# Loading mirror speeds from cached hostfile
# ... (other output trimmed for brevity)

This command installs the glibc-common package, which includes the ldd command. Now you’re ready to use ldd to explore library dependencies in Linux.

Installing ‘ldd’ Command from Source Code

For those who prefer to compile from source code, you can obtain the ldd command from the GNU C Library (glibc) source code. Here’s an example of how to download, compile, and install it:


# Output:
# --2022-01-01 00:00:00--
# Resolving (, 2001:4830:134:3::b
# Connecting to (||:80... connected.
# HTTP request sent, awaiting response... 200 OK
# Length: 17154692 (16M) [application/x-gzip]
# Saving to: ‘glibc-2.33.tar.gz’

# glibc-2.33.tar.gz              100%[====================================================>]  16.36M  1.67MB/s    in 10s

# 2022-01-01 00:00:10 (1.58 MB/s) - ‘glibc-2.33.tar.gz’ saved [17154692/17154692]

After downloading the source code, you can compile and install it:

# Extract the source code

tar xzf glibc-2.33.tar.gz

cd glibc-2.33

# Compile and install

sudo make install

# Output:
# checking build system type... x86_64-pc-linux-gnu
# checking host system type... x86_64-pc-linux-gnu
# ... (other output trimmed for brevity)

Installing Different Versions of ‘ldd’ Command

Installing from Source Code

To install different versions of the ldd command from source code, you simply need to change the version number in the URL when you download the source code. For example, to download version 2.32, you would use

Using Package Managers

To install different versions using package managers like APT or YUM, you need to specify the version number when you install the package. For example, to install version 2.32 using APT, you would use sudo apt-get install libc6-dev=2.32.

Here’s a comparison of the features and compatibilities of different versions:

VersionKey FeaturesCompatibility
2.31Improved performanceUbuntu 20.04
2.32New features like safe-linkingUbuntu 20.10
2.33Bug fixes and performance improvementsUbuntu 21.04

Basic Usage of ‘ldd’ Command

Using the Command

To use the ldd command, you pass the name of the binary file you want to check. For example, to check the libraries needed by the /usr/bin/ssh program, you would use ldd /usr/bin/ssh.

ldd /usr/bin/ssh

# Output:
# (0x00007ffcc35db000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e8b4000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e4c3000)
# /lib64/ (0x00007f1a8ed00000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e251000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e04d000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8de2e000)

Verifying Installation

To verify that the ldd command is installed correctly, you can use the which command. This command shows the path of the binary file for a command. For example, to check the ldd command, you would use which ldd.

which ldd

# Output:
# /usr/bin/ldd

This command shows that the ldd command is installed correctly and its binary file is located in /usr/bin/ldd.

Alternative Methods to Check Library Dependencies in Linux

While the ldd command is a powerful tool for examining library dependencies, there are alternative methods that can provide similar information. One such method is using the objdump command.

Using ‘objdump’ Command

The objdump command is a part of the binutils package and is used to display various information about object files. You can use this command to display the dynamic section of an object file, which includes shared library dependencies.

Here’s an example of how to use objdump to display the shared library dependencies of a program:

objdump -p /usr/bin/ssh | grep NEEDED

# Output:
#  NEEDED     
#  NEEDED     
#  NEEDED     
#  NEEDED     
#  NEEDED     

This command displays the shared libraries needed by the /usr/bin/ssh program. The output shows the library name, similar to the ldd command.

Advantages and Disadvantages of ‘objdump’

The objdump command has several advantages over the ldd command. First, it’s safer to use because it doesn’t actually run any code from the binary file. This makes it a better choice for examining suspicious binary files. Second, it’s part of the binutils package, which is installed on almost all Linux systems.

However, objdump also has some disadvantages. It doesn’t show the full path of the shared libraries, and it doesn’t show the memory addresses where the libraries are loaded. These details can be useful for debugging and are provided by the ldd command.


While both ldd and objdump can be used to examine library dependencies, they each have their strengths and weaknesses. If you’re examining a trusted binary file and need detailed information, ldd is the better choice. If you’re dealing with a suspicious binary file and need to ensure safety, objdump is the way to go.

Troubleshooting Common ‘ldd’ Command Issues

While the ldd command is a powerful tool, it is not without its quirks. Here are some common issues you may encounter when using the ldd command and tips on how to resolve them.

‘ldd’ Command Not Found

If you encounter an ‘ldd: command not found’ error, it means the ldd command is not installed on your system or its path is not included in the PATH environment variable. You can verify this by using the which command:

which ldd

# Output:
# ldd not found

To resolve this issue, you need to install the ldd command or add its path to the PATH environment variable.

‘ldd’ Command Shows ‘not a dynamic executable’

If the ldd command shows ‘not a dynamic executable’ error, it means the file you’re trying to check is not a dynamically linked executable. The ldd command only works on dynamically linked executables.

Here’s an example of this error:

ldd /bin/date

# Output:
# not a dynamic executable

To resolve this issue, you need to check a dynamically linked executable. You can verify if a file is a dynamically linked executable by using the file command:

file /bin/date

# Output:
# /bin/date: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/, for GNU/Linux 3.2.0, BuildID[sha1]=4cf3bccc2e35cdad5a13c04a393b014040408df6, stripped

This command shows that the /bin/date file is a dynamically linked executable.

‘ldd’ Command Shows ‘no version information available’

If the ldd command shows ‘no version information available’ warning, it means the shared library has a version number that is higher than the version number that the ldd command expects. This warning is generally harmless and can be ignored.

Here’s an example of this warning:

ldd /bin/ls

# Output:
# /usr/bin/ls: /lib/x86_64-linux-gnu/ version `GLIBC_2.28' not found (required by /usr/bin/ls)
# (0x00007fff99dfa000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e8b4000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e4c3000)
#         /lib64/ (0x00007f1a8ed00000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e251000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e04d000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8de2e000)

In this output, the GLIBC_2.28' not found warning indicates that the library has a version number that is higher than the version number that the ldd command expects.

Library Dependencies in Linux

Linux, like other operating systems, relies heavily on libraries. These libraries are collections of pre-compiled routines or data structures that a program can utilize. They provide a means to share code among multiple applications, thereby reducing redundancy, minimizing application size, and enhancing maintainability.

Static vs Dynamic Libraries

Libraries in Linux can be broadly categorized into static and dynamic libraries. Static libraries, as the name suggests, are linked to the program at compile time. They form part of the executable, leading to larger binary files. On the other hand, dynamic libraries are linked at runtime, meaning they are not included in the binary file. This results in smaller executables and improved memory efficiency, as multiple programs can share the same dynamic library loaded in memory.

Understanding ‘ldd’ and Library Dependencies

The ldd command in Linux is a utility that prints the shared libraries required by each program. It’s a crucial tool for developers and system administrators to understand and manage library dependencies. For instance, if you’re developing a program that depends on a specific version of a library, you can use ldd to confirm that the correct version of the library is being used.

Here’s an example of how to use ldd to display the shared libraries required by the /usr/bin/ssh program:

ldd /usr/bin/ssh

# Output:
# (0x00007ffcc35db000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e8b4000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e04d000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8de2e000)
# => /lib/x86_64-linux-gnu/ (0x00007f1a8e4c3000)

This output lists the shared libraries needed by the /usr/bin/ssh program, along with their paths. It’s an invaluable tool for diagnosing runtime problems related to libraries.

The Importance of Managing Library Dependencies

Managing library dependencies is critical in Linux system administration. Proper management ensures that all applications have access to the libraries they need to function correctly. It also prevents ‘dependency hell’, a situation where different applications require different versions of the same library, leading to conflicts and system instability.

In conclusion, understanding and managing library dependencies are crucial aspects of Linux system administration. Tools like the ldd command provide a means to investigate and manage these dependencies, promoting system stability and efficient resource usage.

Exploring the Relevance of Library Management

Library management in Linux is not just about ensuring that your applications run smoothly. It plays a significant role in system administration and security as well. For instance, keeping your libraries updated can help protect your system from vulnerabilities that could be exploited by malicious actors.

Static and Dynamic Linking in Linux

As we’ve mentioned earlier, libraries in Linux can be either static or dynamic. Understanding the difference between these two types of linking is crucial for efficient system administration. Static linking results in larger binary files as all necessary libraries are included in the binary at compile time. This could be beneficial in situations where you want to ensure that your program runs the same way, regardless of the environment.

On the other hand, dynamic linking creates smaller executables, as the libraries are linked at runtime. This means that multiple programs can share the same library, resulting in efficient memory usage. However, it also means that if a shared library is updated or changed, it could potentially affect all programs that depend on it.

# Example of static linking

gcc -static myfile.c -o myfile

# Example of dynamic linking

gcc myfile.c -o myfile

# Output:
# myfile: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/, for GNU/Linux 3.2.0, not stripped

In the above example, the -static flag is used with the gcc command to create a statically linked executable. Without the -static flag, gcc creates a dynamically linked executable.

Further Resources for Mastering Library Management in Linux

If you’re interested in delving deeper into the topic of library management in Linux, here are some resources that can help you expand your knowledge:

  1. GNU C Library Documentation: This is the official documentation for the GNU C Library, which includes the ldd command. It provides in-depth information about how the library works and how to use its various commands and features.

  2. Linux From Scratch: This project provides a step-by-step guide on how to build your own Linux system from scratch. It’s a great resource for understanding the inner workings of Linux, including library management.

  3. Advanced Linux Programming: This online book covers a wide range of topics related to Linux programming, including static and dynamic libraries. It’s a great resource for anyone looking to deepen their understanding of Linux system administration.

By exploring these resources and understanding the concepts of library dependencies, static and dynamic linking, you can enhance your skills in Linux system administration and security.

Wrapping Up: Installing the ‘ldd’ Command in Linux

Throughout this comprehensive guide, we’ve delved into the depths of installing and using the ‘ldd’ command in Linux, a potent tool for managing library dependencies.

We embarked on this journey with the basics of how to install and use the ‘ldd’ command in Linux. We then progressed to more advanced topics, such as using different flags and options, and even compiling from the source. Along the way, we tackled common issues you might face when using the ‘ldd’ command, such as ‘ldd: command not found’ and ‘not a dynamic executable’, equipping you with the knowledge to resolve these challenges.

We also explored alternative approaches to handle library dependencies, such as the ‘objdump’ command. This gave you a broader perspective on managing libraries in Linux, allowing you to choose the method that best suits your needs.

Here’s a quick comparison of these methods:

lddDetailed output, shows full path and memory addressesRuns code from the binary file
objdumpSafer, doesn’t run any code from the binary fileDoesn’t show full path and memory addresses

Whether you’re just starting out with the ‘ldd’ command or you’re looking to enhance your system administration skills, we hope this guide has provided you with a thorough understanding of the ‘ldd’ command and its capabilities.

Understanding and managing library dependencies is a vital aspect of Linux system administration. With the knowledge you’ve gained from this guide, you’re well-equipped to navigate the world of library dependencies in Linux. Happy coding!