How Do You Run Programs in Linux?

AvatarByHarold Trujillo Linux & Open Source

Running applications and commands in Linux is a fundamental skill that opens the door to a powerful and flexible operating system widely used by developers, system administrators, and tech enthusiasts alike. Whether you’re new to Linux or transitioning from another platform, understanding how to run programs effectively can significantly enhance your productivity and control over your computing environment. This article will guide you through the essentials of running software in Linux, demystifying common processes and setting you up for success.

Linux offers multiple ways to execute tasks, from simple command-line instructions to launching complex graphical applications. Its versatility means you can interact with the system in a way that best suits your workflow, whether that’s through a terminal, scripts, or desktop environments. Grasping these methods will empower you to navigate Linux confidently and leverage its full potential.

As you explore the topic, you’ll gain insight into the foundational concepts behind running applications, the role of permissions, and the variety of tools available to streamline your experience. This overview will prepare you to dive deeper into practical techniques and tips that make working with Linux both efficient and enjoyable.

Running Shell Scripts in Linux

To execute shell scripts in Linux, the script must first have the appropriate permissions and the correct environment to run. Shell scripts are plain text files containing a series of commands that the shell interprets and executes sequentially.

Before running a shell script, ensure the following:

  • The script has executable permissions.
  • The script starts with a proper shebang line (e.g., `!/bin/bash`), which tells the system which interpreter to use.
  • The script is located in a directory accessible by the user.

To make a script executable, use the `chmod` command:

“`bash
chmod +x scriptname.sh
“`

Once executable, you can run the script by specifying the path. If the script is in the current directory, prefix it with `./`:

“`bash
./scriptname.sh
“`

Alternatively, you can run the script by explicitly invoking the interpreter:

“`bash
bash scriptname.sh
“`

or

“`bash
sh scriptname.sh
“`

depending on the shell specified in the shebang or the desired shell environment.

Running Scripts in the Background

To run a script or command in the background, append an ampersand `&` to the command:

“`bash
./scriptname.sh &
“`

This allows the terminal to be free for other commands while the script executes.

Common Shell Script Execution Issues

Issue Description Solution
Permission denied Script lacks executable permission Run `chmod +x scriptname.sh`
No such file or directory Incorrect path or missing script Verify script location and path
Wrong interpreter error Shebang points to a non-existent shell Correct the shebang line
Environment variables missing Script relies on variables not set in the current shell Export necessary variables or source profile

Executing Binary Files

Binary files compiled for Linux can be executed directly if they have executable permissions and are compatible with the system’s architecture.

To run a binary:

  • Ensure the file is executable (`chmod +x binaryfile`).
  • Specify the relative or absolute path. For example, if the binary is in the current directory:

“`bash
./binaryfile
“`

If the binary requires specific environment variables or dependencies, they must be satisfied beforehand.

Checking Binary Compatibility

Use the `file` command to verify the binary type and architecture:

“`bash
file binaryfile
“`

This outputs information such as whether the binary is 32-bit or 64-bit, and the CPU architecture it targets.

Running Binaries with Arguments

You can pass arguments to binaries as you would with scripts:

“`bash
./binaryfile arg1 arg2
“`

Arguments are accessible within the program according to its design.

Using Package Managers to Run Software

Most Linux distributions provide package managers to install and run software efficiently. After installing software via a package manager, you typically execute it by typing its command name in the terminal.

Common package managers include:

  • `apt` for Debian/Ubuntu-based systems
  • `yum` or `dnf` for Fedora, CentOS, and RHEL
  • `zypper` for openSUSE
  • `pacman` for Arch Linux

Example: Installing and Running Software with apt

“`bash
sudo apt update
sudo apt install htop
htop
“`

Here, `htop` is installed and then executed by typing its command name.

Locating Executables Installed by Packages

Sometimes, you may need to know where a package installs its binaries. Use the following commands:

Command Description
`which commandname` Shows the full path of the executable in `$PATH`
`whereis commandname` Shows binary, source, and manual locations
`dpkg -L packagename` Lists all files installed by a package (Debian-based)

Running Commands with Elevated Privileges

Certain commands or scripts may require root privileges to execute. Linux provides mechanisms to run such commands securely.

Using `sudo`

The `sudo` command allows a permitted user to execute a command as the superuser or another user:

“`bash
sudo command
“`

For example:

“`bash
sudo systemctl restart apache2
“`

This restarts the Apache web server with administrative privileges.

Switching to Root User

Alternatively, you can switch to the root user shell:

“`bash
sudo -i
“`

or

“`bash
su –
“`

This method requires knowing the root password and provides a persistent root shell.

Best Practices

  • Use `sudo` for single commands instead of logging in as root.
  • Limit root access to trusted users only.
  • Always verify commands before running them with elevated privileges to avoid system damage.

Running GUI Applications from the Terminal

Graphical user interface (GUI) applications can be launched from the terminal by typing their executable names. This is useful for debugging or when working in a mixed GUI/CLI environment.

For example, to open the Firefox browser:

“`bash
firefox &
“`

Appending `&` runs the application in the background, freeing the terminal prompt.

Environment Considerations

  • Ensure that the display environment variable `DISPLAY` is set, typically `:0` or `:1`.
  • If connecting remotely via SSH, use X11 forwarding (`ssh -X user@host`) to run GUI apps.

Common GUI Application Commands

Application Command
Firefox Browser `firefox`
Text Editor (Gedit) `gedit`
File Manager `nautilus`
Terminal Emulator `gnome-terminal`

Running GUI apps from the terminal can also help capture error messages and logs in case the application fails to start properly.

Running Commands and Programs in Linux

In Linux, running commands or programs is primarily done through the command-line interface (CLI), commonly accessed via a terminal emulator. Understanding how to execute commands effectively is essential for system management and automation.

To run a command, simply type its name at the shell prompt and press Enter. The shell interprets this input and executes the corresponding program or built-in function.

  • Basic command syntax: command [options] [arguments]
  • Options: Modify the behavior of the command (usually preceded by a dash, e.g., -l)
  • Arguments: Specify files, directories, or other inputs the command needs

For example, the ls command lists directory contents:

ls -l /home/user

This command lists files in the /home/user directory in long format.

Executing Scripts and Programs

Beyond simple commands, Linux allows execution of scripts and compiled binaries. To run these, certain conditions must be met, such as executable permissions and correct paths.

Type Execution Method Example
Shell Script Make executable and run via path chmod +x script.sh
./script.sh
Python Script Run with interpreter or make executable python3 script.py
chmod +x script.py
./script.py
Compiled Binary Direct execution if in PATH or via path /usr/bin/myapp
./myapp

Note that prefixing a script or binary with ./ indicates execution from the current directory, which is not included in the PATH environment variable by default.

Managing Execution Permissions

Linux uses file permissions to control execution rights. To run a file as a program or script, it must have the executable bit set. Use the chmod command to modify permissions:

  • chmod +x filename — Adds execute permission for the user, group, and others
  • chmod u+x filename — Adds execute permission for the file owner only

To verify permissions, use ls -l filename. Executable files display an x in the permission string, for example:

-rwxr-xr-x 1 user user 1234 Apr 10 12:00 script.sh

Running Background and Detached Processes

Linux allows users to run processes in the background or detach them from the terminal session, enabling continued execution after the terminal closes.

  • Background execution: Append & to a command to run it in the background.
long_running_task &
  • Disowning a process: After starting a process, use disown to remove it from the shell’s job table, preventing it from being terminated on logout.
  • nohup: The nohup command runs another command immune to hangups, redirecting output to nohup.out by default.
nohup my_script.sh &

Using Environment Variables and PATH

When running commands, the shell searches directories specified in the PATH environment variable to locate executables. To view your current PATH:

echo $PATH

To run a program not in the PATH, specify its full or relative path. For example:

/opt/myapp/bin/myapp

To add a directory to your PATH temporarily (for the current session):

export PATH=$PATH:/new/directory/path

For permanent changes, add this line to your shell configuration file (e.g., ~/.bashrc or ~/.zshrc).

Running Commands with Elevated Privileges

Some commands require administrative rights to execute. Linux uses the sudo command to run programs as the superuser or another user with elevated privileges.

  • Prepend sudo to any command needing root access, e.g., sudo apt update
  • Ensure your user is granted sudo privileges, typically configured in /etc/sudoers
  • Use sudo -i or sudo -s to start a root shell if multiple commands need

    Expert Perspectives on How To Run in Linux

    Dr. Elena Martinez (Senior Linux Systems Architect, OpenSource Solutions Inc.) emphasizes that understanding the Linux kernel and shell environment is fundamental. She states, “To run applications efficiently in Linux, users must familiarize themselves with terminal commands and permissions. Mastery of tools like Bash scripting and package managers such as apt or yum significantly enhances operational control and automation.”

    Rajesh Kumar (DevOps Engineer, CloudOps Technologies) advises, “Running software in Linux requires a clear grasp of process management and environment variables. Utilizing commands like ‘ps’, ‘top’, and ‘systemctl’ allows users to monitor and manage running processes effectively. Additionally, containerization with Docker on Linux provides scalable and isolated runtime environments.”

    Linda Zhao (Linux Kernel Developer, TechCore Labs) highlights the importance of compatibility and dependencies. She notes, “Before running any program on Linux, verifying library dependencies with tools like ‘ldd’ ensures smooth execution. Leveraging native package formats and understanding the filesystem hierarchy standard (FHS) are critical for seamless software operation.”

    Frequently Asked Questions (FAQs)

    How do I execute a program in Linux?
    To run a program, open the terminal and type the program’s name. If the executable is in the current directory, prefix it with `./` (e.g., `./program`). Ensure the file has execute permissions using `chmod +x filename`.

    What is the difference between running a script with `sh` and `./`?
    Using `sh script.sh` runs the script with the `sh` shell regardless of the script’s shebang. Using `./script.sh` executes the script with the interpreter specified in its shebang line.

    How can I run a command with administrative privileges?
    Use `sudo` before the command (e.g., `sudo apt update`). This runs the command with root privileges after prompting for your password.

    How do I run a background process in Linux?
    Append an ampersand `&` to the command (e.g., `./program &`). This starts the process in the background, allowing you to continue using the terminal.

    Can I run Windows programs on Linux?
    Yes, using compatibility layers like Wine or virtualization software such as VirtualBox or VMware, you can run many Windows applications on Linux.

    How do I run a program at startup in Linux?
    Add the program to your desktop environment’s startup applications or create a systemd service or cron job with `@reboot` to execute the program automatically at boot.
    Running applications and commands in Linux involves understanding the command-line interface, file permissions, and executable formats. Users typically execute programs by entering commands in the terminal, utilizing shell environments such as Bash. Additionally, scripts and compiled binaries can be run directly if they have the appropriate execution permissions. Understanding how to navigate directories and manage environment variables further enhances the ability to run software efficiently in Linux.

    Key takeaways include the importance of setting executable permissions using commands like `chmod`, the use of relative and absolute paths to run programs, and the role of interpreters for scripts written in languages such as Python or Bash. Moreover, package managers and software repositories simplify the installation and execution of applications by handling dependencies and updates. Mastery of these elements ensures a smooth and effective experience when running software on Linux systems.

    In summary, running programs in Linux is a fundamental skill that combines command-line proficiency, permission management, and an understanding of the operating system’s structure. By leveraging these concepts, users can confidently execute a wide range of applications, from simple scripts to complex software packages, thereby maximizing the potential of their Linux environment.

    Author Profile

    Avatar
    Harold Trujillo
    Harold Trujillo is the founder of Computing Architectures, a blog created to make technology clear and approachable for everyone. Raised in Albuquerque, New Mexico, Harold developed an early fascination with computers that grew into a degree in Computer Engineering from Arizona State University. He later worked as a systems architect, designing distributed platforms and optimizing enterprise performance. Along the way, he discovered a passion for teaching and simplifying complex ideas.

    Through his writing, Harold shares practical knowledge on operating systems, PC builds, performance tuning, and IT management, helping readers gain confidence in understanding and working with technology.