Compiling from source is necessary when software isn't in your distro's repository, you need a newer version, or want custom features; 1. Install build tools like build-essential or base-devel and required libraries; 2. Get source code via git or tarball from project sites; 3. Run ./configure or cmake to set build options and check dependencies; 4. Compile with make -j$(nproc) for faster builds; 5. Install with sudo make install, but track manually or use checkinstall to create packages for easier removal, and always verify sources and document steps to ensure safety and maintainability.

Compiling software from source on Linux gives you control over features, optimizations, and access to the latest versions not yet available in your distribution’s repositories. While package managers like apt, dnf, or pacman are convenient, building from source is essential when you need custom configurations or bleeding-edge updates. Here's a practical guide to help you do it safely and effectively.

Why Compile from Source?

You might need to compile software from source for several reasons:

• The software isn’t available in your distro’s package manager.
• You need a newer version than what’s provided.
• You want to enable or disable specific features (e.g., support for a codec or plugin).
• You're a developer testing changes or contributing to the project.

However, keep in mind: manually compiled software isn’t managed by your package manager, which can complicate updates and removals.

Step-by-Step: How to Compile from Source

1. Install Build Tools and Dependencies

Most Linux distributions don’t include compilation tools by default. You’ll need a compiler (like GCC), make, and other utilities.

On Debian/Ubuntu:

sudo apt update
sudo apt install build-essential autoconf automake libtool

On Fedora/RHEL:

sudo dnf groupinstall "Development Tools"
sudo dnf install autoconf automake libtool

On Arch Linux:

sudo pacman -S base-devel

You’ll also need any library dependencies required by the software (e.g., libssl-dev, zlib1g-dev). These are often listed in README or INSTALL files.

? Pro tip: Look for a requirements.txt, INSTALL.md, or BUILDING.md in the source directory. Many projects now include detailed build instructions.

2. Get the Source Code

You can usually download source code from:

• Project websites (e.g., http://ipnx.cn/link/13c0a0edfa0a93c79ff4c6b17dd8d9fb)
• GitHub, GitLab, or other code hosting platforms

Using git (recommended for active projects):

git clone https://github.com/user/project-name.git
cd project-name

Or download a release tarball:

wget https://example.com/project-1.0.tar.gz
tar -xzf project-1.0.tar.gz
cd project-1.0

3. Configure the Build

Most open-source projects use the GNU Autotools (configure script). Run:

./configure

This checks your system for dependencies, sets up build options, and generates Makefiles.

Common configure options:

• --prefix=/usr/local – Install to /usr/local (default)
• --enable-feature – Turn on optional features
• --disable-feature – Turn off features you don’t need
• --with-library – Specify external library paths

Example:

./configure --prefix=/usr/local --enable-ssl --disable-debug

?? If configure fails, it will tell you which dependencies are missing. Install them and try again.

For CMake-based projects:

mkdir build && cd build
cmake ..

CMake uses cmake instead of configure, and options are passed with -D.

4. Compile the Software

Once configured, compile with:

make

This reads the Makefile and compiles the source code. Depending on the software, this can take seconds or hours.

To speed things up, use multiple CPU cores:

make -j$(nproc)

5. Install the Software

After successful compilation:

sudo make install

This copies binaries, libraries, and configuration files to their final locations (e.g., /usr/local/bin).

? Warning: Installing with sudo make install bypasses the package manager. You won’t be able to easily uninstall or track what was installed.

Alternative: Use make install DESTDIR=/path/to/staging to create a package or test installation.

Managing Manually Installed Software

Since the package manager doesn’t track your builds, consider:

• Keeping a log of what you compiled and which options you used.

• Using tools like checkinstall (on Debian/Ubuntu) to generate a .deb or .rpm package:

  sudo checkinstall

  This lets you uninstall via dpkg or rpm later.

• Or use containers or local prefixes (e.g., --prefix=$HOME/.local) to avoid system-wide changes.

---

Troubleshooting Common Issues

• “Command not found” after install?
  Make sure your PATH includes the install prefix (e.g., /usr/local/bin).

• Missing header files or libraries?
  Install the corresponding -dev or -devel package (e.g., libcurl4-openssl-dev).

• Permission denied when running make install?
  Use sudo, but be cautious—double-check the install prefix.

• Out of disk space during build?
  Compilation can require a lot of temporary space. Clean up with make clean when done.

---

Final Notes

Compiling from source isn’t always necessary, but it’s a valuable skill. It gives you flexibility and deeper understanding of how software works on Linux.

Stick to trusted sources, verify checksums or GPG signatures when possible, and document your steps.

Basically, if you can read the README, install dependencies, and run configure, make, and make install, you’re good to go. It’s not magic—just code being built where you control the knobs.

The above is the detailed content of A Guide to Compiling Software from Source on Linux. For more information, please follow other related articles on the PHP Chinese website!