Compiling And Running Putty Linux From Source

Published in PuTTY Blog•Article

Compiling and Running PuTTY Linux From Source: A Comprehensive Guide

For many years, PuTTY has been the go-to SSH and Telnet client for Windows users, renowned for its simplicity and robust features. While Linux distributions typically come equipped with powerful native SSH clients like OpenSSH, there are specific scenarios where users might prefer to leverage the familiar interface and functionalities of PuTTY Linux. This guide will walk you through the process of compiling PuTTY from source on your Linux machine, offering a deeper understanding and greater control over your terminal emulator.

Building software from its source code provides several advantages, including accessing the absolute latest features, applying custom patches, or simply understanding how a program is put together. For those who frequently switch between Windows and Linux environments, having a consistent PuTTY on Linux experience can streamline workflow and reduce context switching. This detailed walkthrough ensures you can successfully get PuTTY for Linux up and running.

Whether you're a developer, system administrator, or just someone curious about customizing their tools, learning to build PuTTY on Linux offers invaluable insight. We'll cover everything from gathering prerequisites to executing the final installation, ensuring you have a fully functional PuTTY client for Ubuntu or other popular distributions. Let's dive into transforming the raw source code into a powerful Linux terminal emulator that meets your specific needs.

Why Compile PuTTY for Linux from Source?

While many Linux users are content with the ssh command-line utility, there are compelling reasons to consider compiling PuTTY from source. One primary benefit is gaining access to the absolute latest PuTTY release and features before they might be packaged for your specific distribution. This is particularly useful for developers who need cutting-edge functionalities or security patches. Compiling from source also allows for greater customization; you can enable or disable specific features, apply experimental patches, or even integrate it with other tools if you have the programming expertise.

Furthermore, building PuTTY on Linux from its source code ensures you have a version specifically optimized for your system's architecture and libraries. This can sometimes lead to slightly better performance or stability compared to generic pre-compiled binaries, though the difference is often marginal for a tool like PuTTY. For those who appreciate the graphical interface and session management capabilities that PuTTY offers on Windows, having a native PuTTY SSH client for Linux provides a consistent user experience. It's also an excellent learning exercise for anyone interested in how open-source software is developed and deployed, deepening your understanding of the Linux ecosystem.

Prerequisites for Building PuTTY on Linux

Before you can begin building PuTTY on Linux, you'll need to ensure your system has the necessary development tools and libraries installed. These prerequisites are crucial for the compilation process to succeed. Without them, the build system won't be able to interpret the source code or link it against required system components.

Here's a list of essential packages you'll likely need to install. The commands provided are for Debian/Ubuntu-based systems, but similar packages exist for Fedora/RHEL or Arch Linux.

  • Build Essentials: This meta-package includes gcc, g++, make, and other fundamental tools required for compiling software.
  • GTK+ Development Libraries: PuTTY's graphical interface on Linux relies on GTK+. You'll need the development headers for GTK+ 2.x or 3.x.
  • pkg-config: A utility that helps configure build systems to find the correct libraries.

To install these PuTTY dependencies on a Debian/Ubuntu system, open your terminal and run:

sudo apt update sudo apt install build-essential pkg-config libgtk-3-dev

For Fedora/RHEL systems, the command would be:

sudo dnf install @development-tools pkg-config gtk3-devel

Ensure these packages are successfully installed before proceeding. Having the right tools in place is the first critical step in a smooth PuTTY compilation guide.

Downloading the PuTTY Source Code for Linux

The next step in getting PuTTY for Linux is to obtain the source code itself. It's always recommended to download the source directly from the official project website to ensure authenticity and access to the latest stable version. The official source for PuTTY is maintained by Simon Tatham. You can visit the [official project website] (./visiting-puttyorg-the-official-project-website) to find the download links.

There are typically two main ways to get the PuTTY source code download:

  1. Direct Download: You can download a compressed archive (e.g., .tar.gz) of a specific release from the PuTTY website. Navigate to the "Download" section, find the "Source code" link for the latest stable version, and download it.
  2. Using Git: For developers or those who want the absolute latest (potentially unstable) development version, cloning the Git repository is the preferred method. This also makes it easier to update your local copy later.

Let's use the Git method, as it's often more convenient for source-based builds. First, ensure you have Git installed:

sudo apt install git # On Debian/Ubuntu sudo dnf install git # On Fedora/RHEL

Once Git is installed, you can clone the PuTTY repository to your local machine. Choose a directory where you want to store the source code, for example, your home directory:

cd ~ git clone https://git.tartarus.org/simon/putty.git cd putty

This command will create a putty directory containing all the source files. Now you have the foundation for your custom PuTTY build.

Compiling PuTTY for Linux: Step-by-Step Guide

With the source code downloaded and prerequisites installed, you're ready to dive into the core process of compiling PuTTY from source. This involves configuring the build system, compiling the code, and finally installing the binaries. Follow these steps carefully to ensure a successful PuTTY compilation guide.

Preparing the Build Environment for PuTTY Linux

Before compiling, you need to configure the build environment. The PuTTY source code uses a configure script, which checks your system for necessary libraries and tools and generates the appropriate Makefile for your environment. This step is crucial for building PuTTY on Linux correctly.

Navigate into the putty directory (if you're not already there):

cd ~/putty # Or wherever you cloned/extracted the source

Now, run the configure script. You might want to specify some options. For a standard graphical PuTTY for Linux client, you'll typically want to enable GTK+ support.

./configure --with-gtk

This command will run a series of checks. It will look for GTK+ libraries, pkg-config, and other components. If any essential dependencies are missing, the configure script will usually report an error, indicating what needs to be installed. For example, if libgtk-3-dev was not installed, it might complain about missing GTK+ development files. Successfully completing this step means your system is ready for the actual compilation.

Executing the Make Command for PuTTY Linux

After the configure script has successfully generated the Makefile, the next step is to compile the source code. This is done using the make command, which reads the Makefile and orchestrates the compilation process by invoking the C compiler (gcc) on all the source files. This is where your PuTTY open source project starts to take shape.

From within the putty directory, simply run:

make

The make command will display a lot of output as it compiles each source file into object code and then links them together to create the executable binaries. This process can take a few minutes, depending on your system's processor speed.

If make completes without errors, you will have several executable files generated within the putty directory. These include putty (the main graphical client), pscp (secure copy client), psftp (secure file transfer client), and puttygen (key generator). Successfully executing make means you're very close to running PuTTY on Linux. If you encounter errors during this stage, double-check your configure step and ensure all PuTTY dependencies are correctly installed.

Installing the Compiled PuTTY Linux Binaries

Once the compilation is complete, the final step is to install the compiled binaries to a system-wide location, making them accessible from anywhere on your system. This is typically done using sudo make install.

From the putty directory, run:

sudo make install

This command will copy the putty, pscp, psftp, and puttygen executables to /usr/local/bin (or a similar location, depending on your configure options) and install any associated manual pages. After this, you should be able to simply type putty in your terminal to launch the graphical client.

Congratulations! You have now successfully completed the PuTTY compilation guide and installed your own custom PuTTY build on your Linux system.

Running and Using Your Compiled PuTTY Linux Client

With PuTTY for Linux successfully compiled and installed, you can now launch and use it just like any other application. The primary executable, putty, will launch the graphical interface, providing the familiar session configuration options.

To start your newly compiled PuTTY SSH client for Linux, simply open a terminal and type:

putty

This will bring up the PuTTY configuration window, where you can enter the hostname or IP address of your remote server, select the connection type (SSH, Telnet, Rlogin, Raw), and configure various session settings. You can save your session profiles for quick access, just like on Windows. For detailed steps on configuring your connections, you might want to refer to our guide on [configuring PuTTY SSH client] (./configuring-putty-ssh-client-for-remote-access).

Beyond the main putty client, you also have access to other powerful tools that were compiled alongside it:

  • pscp: A command-line utility for securely copying files between your local machine and a remote server using SSH.
  • psftp: An interactive command-line SFTP client for secure file transfers.
  • puttygen: A tool for generating SSH key pairs, which are essential for secure, passwordless authentication.

These tools make your PuTTY on Linux installation a comprehensive suite for remote server administration and secure file transfers, offering a robust alternative or complement to standard Linux utilities.

Troubleshooting Common PuTTY Linux Compilation Issues

Even with careful steps, you might encounter issues when compiling PuTTY from source. Don't worry, most problems are common and have straightforward solutions. Understanding these can save you a lot of time and frustration, especially when working on a custom PuTTY build.

Here are some frequent compilation issues and how to address them:

  • Missing Dependencies: The most common problem is a missing development library or tool. The configure script is usually good at identifying these. If configure fails, carefully read the error message. It will often tell you which package or library is missing (e.g., "No package 'gtk+-3.0' found"). Revisit the "Prerequisites" section and ensure all PuTTY dependencies are installed. Remember to search for the correct package name for your specific Linux distribution.
  • make Errors: If make fails, it often points to a compilation error in the source code itself, or more commonly, an issue with the compiler finding necessary header files. This can sometimes be a symptom of an incorrectly configured configure step. Try running make clean to remove any previously compiled object files, then re-run configure and make.
  • ./configure: No such file or directory: This means you're not in the correct directory. Ensure you have cd'd into the putty source directory after cloning or extracting.
  • Permission Denied during make install: This error occurs if you forget to use sudo before make install. Installing to system directories requires root privileges.
  • putty command not found after installation: If sudo make install completed without errors, but typing putty in the terminal doesn't work, it might be a PATH issue. The binaries are usually installed to /usr/local/bin, which should be in your system's PATH. Try logging out and back in, or restarting your terminal. You can also try running it with the full path: /usr/local/bin/putty.

If you encounter persistent issues, searching online forums or the PuTTY mailing list for specific error messages can often yield solutions from other users who have faced similar challenges. Remember that PuTTY open source means a community often exists to help.

Keeping Your PuTTY Linux Installation Updated

Once you have successfully compiled and installed PuTTY for Linux from source, you might wonder how to keep it updated with the latest features and security fixes. Unlike package manager installations (e.g., apt install putty), which handle updates automatically, a source-compiled installation requires a manual process.

To update your PuTTY on Linux installation, you essentially repeat the download and compilation steps:

  1. Navigate to your source directory: cd ~/putty (or wherever you cloned it).
  2. Fetch the latest changes: If you used Git, run git pull to download the newest source code from the repository. If you downloaded a .tar.gz file, you'll need to download the new version, extract it to a new directory, and repeat the process from there.
  3. Clean previous build artifacts: Run make clean to remove old compiled files.
  4. Re-configure (optional but recommended): Run ./configure --with-gtk again. This ensures that any new build requirements or changes are correctly detected.
  5. Re-compile: Run make to compile the updated source code.
  6. Re-install: Run sudo make install to overwrite the old binaries with the new ones.

This process ensures your PuTTY Linux client is always running the latest PuTTY release. While it requires a bit more effort than a simple apt upgrade, it gives you complete control over the version you're running and the features included in your custom PuTTY build.

FAQ: Compiling and Running PuTTY Linux From Source

Here are some common questions regarding compiling PuTTY from source on Linux.

Is PuTTY available for Linux directly through package managers?

Yes, many Linux distributions offer pre-compiled PuTTY for Linux packages through their official repositories. For example, on Debian/Ubuntu, you can often install it with sudo apt install putty. However, these versions might not always be the absolute latest PuTTY release, and compiling from source gives you more control and customization options.

Why would I use PuTTY on Linux when OpenSSH is built-in?

While OpenSSH is powerful and widely used, PuTTY on Linux offers a familiar graphical interface for users accustomed to the Windows version. It provides easy session management, robust configuration options accessible through a GUI, and integrated tools like pscp and psftp that some users find more intuitive than their OpenSSH counterparts. It's often a matter of personal preference and workflow.

How do I uninstall PuTTY Linux if I compiled it from source?

If you installed using sudo make install, you can often uninstall by navigating back to the source directory and running sudo make uninstall. This command reads the Makefile and removes the files that were installed. If make uninstall is not available or doesn't work, you'll need to manually remove the executables (e.g., putty, pscp, psftp, puttygen) from /usr/local/bin and any manual pages from /usr/local/share/man.

Is it safe to download PuTTY source from unofficial sources?

No, it is strongly recommended to only download the PuTTY source code download from the official PuTTY website (www.putty.org) or its official Git repository. Downloading from unofficial sources poses a significant security risk, as the code could be tampered with, potentially introducing malware or backdoors into your system. Always verify the source to ensure you are getting genuine PuTTY open source code.

Can I use PuTTY for Linux to connect to serial ports?

The graphical PuTTY for Linux client, when compiled with appropriate support, can indeed be used for serial connections, similar to its Windows counterpart. This functionality is often enabled by default if the necessary serial port libraries are detected during the configure step. It provides a convenient Linux terminal emulator for interacting with devices via serial.

Conclusion

Successfully compiling and running PuTTY Linux from source is a rewarding experience that empowers you with the latest features, enhanced security, and a deeper understanding of your system. This guide has walked you through every critical step, from installing essential PuTTY dependencies to executing the final installation, ensuring your custom PuTTY build is ready for action. You now have a powerful, familiar PuTTY SSH client for Linux that integrates seamlessly into your workflow, offering robust remote access capabilities.

By taking the time to build PuTTY on Linux, you gain not just a tool, but also valuable insight into the open-source development process. Whether you're managing remote servers, transferring files securely, or simply prefer the PuTTY on Linux interface, you're now equipped to leverage this versatile Linux terminal emulator to its fullest potential. Explore its features, customize your sessions, and enjoy the control that comes with a source-compiled application. For more tips on optimizing your PuTTY for Linux experience, consider exploring our other guides on [PuTTY features] (./top-5-putty-features-you-should-be-using).

;