Input/Output Redirection in Linux
Linux
10.04.2025
Reading time: 8 min
Share
One of the key principles of the UNIX philosophy is that all command-line interface (CLI) commands should accept text as input and produce text as output. Since this concept was applied in the development of UNIX (and later Linux), there are commands to receive text as input, perform an operation on it, and then produce text as output. Commands that read text input, modify it in some way, and then produce text output are sometimes called filters.
To use filter commands and work with text streams effectively, we should understand several types of redirection available with most commands: pipelines, standard output redirection, error output redirection, and input redirection.
Standard Output
When a command executes without errors, the resulting output is called standard output, also known as STDOUT. By default, this output is sent to the terminal where the command is run.
We can redirect standard output from the command so it goes to a file instead of the terminal using the greater-than symbol (>) followed by the target file. For example, the command ls ~ lists files in the home directory. To save this list to a text file:
ls ~ > /tmp/home.txtThe contents of home.txt would then look like this:
cat /tmp/home.txt
Desktop
Documents
Downloads
Music
Pictures
Public
Templates
Videos
Using a single > creates a new file or overwrites an existing one. Using two greater-than symbols >> also creates a file if it doesn't exist but appends output to the end if the file already exists. For example, to append the output of the date command:
date >> /tmp/home.txt cat /tmp/home.txt
Desktop
Documents
Downloads
Music
Pictures
Public
Templates
Videos
Sun Mar 30 07:36:02 UTC 2025
Standard Error
In Linux, when a command encounters an error, it produces output known as standard error, also called stderr or STDERR. Like standard output, it is usually sent to the same terminal. The file descriptor number for standard error is 2.
For example, trying to run:
ls /junkWill produce:
ls: cannot access /junk: No such file or directorySince this output goes to stderr, using just > won't redirect it:
ls /junk > output
ls: cannot access /junk: No such file or directoryTo redirect error messages, use the correct file descriptor:
ls /junk 2> /tmp/ls.errLike with standard output, > will create or overwrite the file. To append to the error log instead:
ls /junk 2>> /tmp/ls.errSome commands produce both stdout and stderr. For example:
find /etc -name passwd
/etc/pam.d/passwd
/etc/passwd
find: '/etc/ssl/private': Permission denied
You can redirect these into two separate files:
find /etc -name passwd > /tmp/output.txt 2> /tmp/error.txtTo verify:
cat /tmp/output.txt
/etc/pam.d/passwd/etc/passwdcat /tmp/error.txt
find: '/etc/ssl/private': Permission deniedIf you don't want to display or save error messages, redirect them to /dev/null. This file acts like a trash bin where all input disappears. Any output type can be redirected there, most commonly stderr:
find /etc -name passw 2> /dev/null
/etc/pam.d/passwd
/etc/passwdCombining Standard Output and Error
To redirect both stdout and stderr into a single file, use either of the following methods:
ls > /tmp/ls.all 2>&1ls &> /tmp/ls.allBoth commands create the file /tmp/ls.all containing both standard output and error messages. In the first command, 2>&1 means "send stderr to the same place as stdout." The second uses &> as shorthand for "redirect all output."
Standard Input
Standard input, also known as stdin or STDIN, typically comes from the keyboard and is entered by the user running the command. While most commands can read input from files, some expect the user to type input manually using the keyboard.
One common way to use text files as standard input is by creating script files. Scripts are simple text files that are interpreted by the shell when given the appropriate permissions and start with #!/bin/sh in the first line, which tells the shell to interpret the script as standard input:
cat examplescriptfile.sh
#!/bin/sh
echo HelloWorldWhen a script file is called in the command line using the ./ syntax, the shell executes all commands in the script file and returns the result to the terminal window or wherever the output is directed:
./examplescriptfile.sh
HelloWorldIn some cases, it’s useful to redirect standard input so that it comes from a file instead of the keyboard. A good example where input redirection is desirable is the tr command. The tr command translates characters by reading from standard input, converting one set of characters to another, and writing the transformed text to standard output.
For example, the following tr command takes input from the user (via keyboard) to convert all lowercase letters to uppercase:
tr 'a-z' 'A-Z'
hello
HELLOThe tr command will not stop reading from standard input unless it is terminated. You can do this by pressing Ctrl+D.
The tr command does not accept a filename as a command-line argument. To perform translation using a file as input, use input redirection. To do this, enter the command with its parameters and arguments, followed by the less-than symbol < and the file path to be used for input. For example:
cat Documents/animals.txt
1 retriever
2 badger
3 bat
4 wolf
5 eagle
tr 'a-z' 'A-Z' < Documents/animals.txt
1 RETRIEVER
2 BADGER
3 BAT
4 WOLF
5 EAGLE
Command Pipelines
Command pipelines are often used to efficiently apply filter commands. In a command pipeline, the output of one command is sent to another command as input. In Linux and most operating systems, the vertical bar | represents a pipeline between two commands.
For example, if the output of the history command is very long, you can send it to the less command to display one page at a time:
history | lessAn even better example is taking the output of history and filtering it using the grep command. In the following example, the text output from history is redirected to grep as input. The grep command matches lines containing "ls" and sends the result to standard output:
history | grep "ls"
1 ls ~ > /tmp/home.txt
5 ls l> /tmp/ls.txt
6 ls 1> /tmp/ls.txt
7 date 1>> /tmp/ls.txt
8 ls /junk
9 ls /junk > output
10 ls /junk 2> /tmp/ls.err
11 ls /junk 2>> /tmp/ls.err
14 ls > /tmp/ls.all 2>&1
15 ls &> /tmp/ls.all
16 ls /etc/au* >> /tmp/ls.all 2>&1
17 ls /etc/au* &>> /tmp.ls.all
20 history | grep "ls"
Command pipelines become especially powerful when combining three or more commands. For example, view the contents of the os.csv file in the Documents directory:
cat Documents/os.csv
1970,Unix,Richie
1987,Minix,Tanenbaum
1970,Unix,Thompson
1991,Linux,Torvalds
The following command line extracts some fields from os.csv using the cut command, then sorts those lines using sort, and finally removes duplicates using uniq:
cut -f1 -d',' Documents/os.csv | sort -n | uniq
1970
1987
1991
The tee Command
The tee command splits the output of a command into two streams: one is directed to standard output (displayed in the terminal), and the other is written to a file.
The tee command is useful for logging the output of a command or script. For example, to record the execution time of a process, start with the date command and copy the output to a file timer.txt:
date | tee timer.txt
Tue Apr 2 02:21:24 UTC 2025The timer.txt file now contains a copy of the date, the same output as shown above:
cat timer.txt
Tue Apr 2 02:21:24 UTC 2025To append the time to the end of timer.txt, use the -a option:
date | tee -a timer.txt
Tue Apr 2 02:28:43 UTC 2025To run multiple commands as one line, use the semicolon ; as a separator:
date | tee timer.txt; sleep 15; date | tee -a timer.txt
Tue Apr 2 02:35:47 UTC 2025
Tue Apr 2 02:36:02 UTC 2025The command above displays and writes the first date output, pauses for 15 seconds, then displays and writes the second date output. The timer.txt file now contains a persistent execution log.
The xargs Command
Command options and parameters are typically specified directly in the command line as arguments. Alternatively, you can use the Linux xargs command to collect arguments from another input source (such as a file or standard input) and pass them to a command. xargs can be called directly and will accept any input:
xargs
Hello
ThereTo exit xargs, press Ctrl+C.
By default, xargs passes input to the echo command if no other command is explicitly given. After pressing Ctrl+D, xargs sends the input to echo:
Pressing Ctrl+D after exiting
xargswith Ctrl+C will also exit the current shell. To send input toechowithout exiting the shell, press Ctrl+D duringxargsexecution.
The Linux xargs command is most useful when used in a pipeline. The following example uses the touch command to create four files. The file names are 1a, 1b, 1c, and 1d, based on the output from the echo command:
echo '1a 1b 1c 1d' | xargs touch
ls
1a 1c Desktop Downloads Pictures Templates timer.txt
1b 1d Documents Music Public Videos
Conclusion
We’ve reviewed input/output stream redirection in Linux: standard output redirection, error output redirection, input redirection, and pipelines. Understanding these capabilities makes working with bash scripts easier and helps efficiently administer servers running Linux-based operating systems.
Linux
10.04.2025
Reading time: 8 min
Share
Similar
Linux
What is a Daemon in Computing?
The term daemon comes from a word in ancient Greek mythology that referred to an immaterial being influencing the human world.
In computing, especially in UNIX-like operating systems, a daemon is a background process that runs without direct interaction from the user. It doesn’t depend on a terminal or user interface and typically starts with the system boot or under specific conditions.
What is a Daemon
The main function of a daemon is to provide specific services to other processes or users. For example, a daemon might listen on network ports waiting for connections, monitor system events and respond when certain conditions are met, manage scheduled jobs (like cron), send emails (sendmail), and more.
In Windows, the closest equivalent to a daemon is a service. The difference lies mainly in how they're started, registered, managed, and configured within operating systems. However, their purpose is the same: to ensure continuous background operation of certain functions or services.
Key Characteristics of a Daemon
Runs in the background: Users typically don’t see the daemon’s interface; it doesn’t write to standard output (or redirect it to logs), nor does it request keyboard input.
Autonomous: A daemon starts either at system boot when triggered by an init system (like systemd), or manually by a user (via scripts, cron, etc.).
Long-lived: Ideally, a daemon runs indefinitely unless a critical error occurs or it receives an explicit stop signal.
Isolated: Usually runs under a separate user/group account to minimize privileges, making services more secure and easier to manage.
Logging: Instead of using standard input/output, daemons log information to log files or the system logger (journald, syslog, etc.), which is helpful for debugging and diagnostics.
Daemons in Linux
Historically, nearly all system background tasks in Linux are implemented as daemons. The OS includes dozens of them, each responsible for a specific function. Here are some examples:
sshd (Secure Shell Daemon): Listens on port 22 (by default) and allows remote users to connect via encrypted SSH. Without sshd, remote terminal access is almost impossible.
cron: A job scheduler daemon. It checks crontab entries and runs scripts or commands on a schedule, such as log cleanup, sending reports, system checks, etc.
syslogd / rsyslog / journald: System logging daemons that collect messages from the kernel, utilities, other daemons, and apps, and save them in log files or the journal.
NetworkManager or Wicd: Daemons that manage network settings — automating connections to wired/wireless networks, switching, configuring VPNs, and more.
These daemons start at system boot and are registered with the system service manager (e.g., systemd). They run until the system is shut down or rebooted. Users interact with them indirectly — through config files, terminal commands (service, systemctl), or network requests (if the daemon provides HTTP/S, SSH, or another network interface).
How to Create and Manage Daemons
To implement a daemon, follow these steps:
Forking the process: The parent process calls fork() and continues running the daemon code in the child process.
Detach from controlling terminal (setsid): To avoid user interference (e.g., closing the terminal), the daemon calls setsid() to start a new session and become its leader.
Close standard input/output descriptors: Since the daemon shouldn't write to the screen or wait for input, stdin, stdout, and stderr are closed or redirected to log files.
Handle signals and logging: To support graceful shutdown or config reloads, the daemon must handle signals (SIGTERM, SIGHUP, etc.). Logging is usually done via syslog or files.
Main loop: After initialization, the daemon enters its main loop: waiting for events, handling them, and repeating until stopped.
Let’s see how to create a daemon on Ubuntu 22.04 using a Hostman cloud server
1. Write the Daemon in C
Create a file called mydaemon.c and insert the following code:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
int main() {
// Open syslog
openlog("mydaemon", LOG_PID, LOG_DAEMON);
syslog(LOG_NOTICE, "Daemon started");
// Main infinite loop
while (1) {
// Your background tasks: monitoring, queue handling, etc.
syslog(LOG_NOTICE, "Performing task...");
sleep(60);
}
// If we ever exit the loop
syslog(LOG_NOTICE, "Daemon stopped");
closelog();
return 0;
}
2. Compile the Program
First, update your packages:
sudo apt update && sudo apt upgrade
Install the GCC compiler if not already installed:
sudo apt install gcc
Compile the daemon:
gcc mydaemon.c -o mydaemon
3. Move the Executable
Move the binary to /usr/local/bin/, a standard location for custom utilities:
mv mydaemon /usr/local/bin/mydaemon
4. Create a systemd Service
Create a unit file called mydaemon.service:
sudo nano /etc/systemd/system/mydaemon.service
Insert the following content:
[Unit]
Description=My Daemon
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/mydaemon
Restart=on-failure
[Install]
WantedBy=multi-user.target
Explanation of the fields:
Description: Description shown in systemctl status.
After=network.target: Ensures the daemon starts after the network is up.
Type=simple: The daemon doesn’t fork, it runs as a single process.
ExecStart: Path to the daemon executable.
Restart=on-failure: Restart automatically if the daemon crashes.
WantedBy=multi-user.target: Makes the service start in the standard multi-user environment.
5. Start and Monitor the Daemon
sudo systemctl daemon-reload # Reload systemd configuration
sudo systemctl start mydaemon # Start the daemon
sudo systemctl status mydaemon # Check its status
If everything works, the status will show active. To view logs:
journalctl -u mydaemon.service -e
Examples of Daemon Usage
Web Servers
Their job is to listen on a network port (usually 80 or 443), accept HTTP/HTTPS requests, generate a response (an HTML page, JSON data, etc.), and send the result back to the client. In most cases, a web server starts with the system and continues running until the server is shut down or a stop command is issued (e.g., systemctl stop nginx).
Database Daemons
MySQL/MariaDB, PostgreSQL, MongoDB — all of these are also daemons. They start with the system and continue running in the background, accepting requests from client applications or web services. These daemons typically log activity, support configuration via files, and are managed using special utilities (or systemd).
Job Schedulers (cron, atd)
The cron daemon checks the schedule table (crontab) and runs programs at the times or intervals specified by the user. This makes it possible to automate backups, system updates, health checks, and many other routine tasks.
atd is a similar daemon but executes tasks only once at a specific time (unlike cron, which runs tasks on a regular schedule).
Access and Control Services (sshd, xrdp)
sshd (Secure Shell Daemon) provides remote access via the SSH protocol. xrdp enables remote desktop connections using the RDP protocol. It acts as a daemon that listens for network connections on a specified port.
Init System Daemons (systemd, init, Upstart)
In modern systems, the role of the "main daemon" is fulfilled by systemd (replacing the older SysV init system). systemd is the first process to start after the kernel and is responsible for launching and managing all other services and processes. It starts them in parallel and handles their dependencies. Simply put, systemd is itself a daemon that “orchestrates” all others in the system.
Advantages and Disadvantages of Daemons
Advantages:
Automation: Daemons enable system behavior to be automated — from responding to network requests to scheduling tasks — without user intervention.
Isolation: Running under separate user/group accounts and detaching from terminals enhances security by limiting potential damage in case of compromise.
Continuous Operation: A daemon can keep servicing requests (like a web server) without interruption even if the user logs out or the console is closed.
Manageability: Linux provides system tools (e.g., systemd, init scripts) to centrally manage all daemons: starting, stopping, restarting, and logging.
Disadvantages:
Debugging Complexity: Since daemons run in the background and don’t output to the console, debugging requires thorough logging and more complex setups (debug flags, tracing, etc.).
Security Risks: If a daemon runs with elevated privileges (e.g., as root), any vulnerability can potentially compromise the entire system. It's best to run daemons under limited accounts.
Dependency Management: Some daemons may fail if, for example, they need network access before the network is up. Modern init systems solve this, but with classic SysV init scripts, this used to be a common issue.
Increased Resource Usage: Any constantly running background process consumes system resources (memory, CPU time). If there are too many daemons, this can impact performance, especially on systems with limited resources.
Conclusion
Daemons are central to Linux operating systems' architecture, offering vast automation and background services capabilities. They allow administrators to flexibly configure network operations, scheduled tasks, logging, security systems, and many other components.
Writing your own daemon requires understanding processes, signals, system calls, and careful attention to logging and security.
Modern init systems (especially systemd) have simplified daemon management and service logic, making the creation of custom services more structured and flexible. However, it remains a complex field that demands careful design, debugging, and ongoing maintenance.
11 April 2025 · 8 min to read
Linux
Setting Up a DNS Server
A personal DNS server can be useful if your provider doesn't offer this service or if existing solutions don't suit your needs. The easiest way to set one up is via a control panel (cPanel, CloudPanel, HestiaCP, etc), but you can also do it manually using the terminal and the Linux DNS Server BIND 9.
Preparing the Server
Let's say you've rented a Hostman Linux VPS and want to use your own DNS servers. To do that, you need to meet two conditions:
Order another public IP address — DNS setup requires at least two IPs.
Open DNS port 53, which is necessary for the nameserver to work.
Ubuntu/Debian
Update the package list:
apt update
Allow incoming packets on port 53 UDP in the firewall:
iptables -I INPUT -p udp --dport 53 -j ACCEPT
Save the firewall rules:
iptables-save
CentOS
Install system updates:
yum update
Install time synchronization utility:
yum install chrony
Set your timezone, for example:
timedatectl set-timezone Europe/Cyprus
Enable and start the time synchronization service:
systemctl enable chronyd --now
Open port 53:
firewall-cmd --permanent --add-port=53/udp
Apply the updated firewall rules:
firewall-cmd --reload
Installing the DNS Server
This guide uses BIND 9 to create an IP-based DNS server.
Ubuntu/Debian
Install required packages:
apt-get install bind9 dnsutils
Enable autostart:
systemctl enable bind9
Start the service:
systemctl start bind9
Check if it's running:
systemctl status bind9
Look for active status in the output.
CentOS
Install the DNS utility:
yum install bind
Enable autostart:
systemctl enable named
Start the service:
systemctl start named
Check its status:
systemctl status named
You should see active in the output.
Basic DNS Server Configuration
The settings are defined in the configuration file.
Ubuntu/Debian
Open the config file:
vi /etc/bind/named.conf.options
In the listen-on block, specify the networks, e.g.:
listen-on {
10.10.10.0/24;
10.1.0.0/16;
};
To allow the DNS server to listen on all interfaces, either omit this line or use any.
In the allow-query line, specify who can make queries:
allow-query { any; };
Restart the service for changes to take effect:
systemctl restart bind9
CentOS
Open the config file:
vi /etc/named.conf
Find these lines:
listen-on port 53 { 127.0.0.1; localhost; 192.172.160.14; };
...
allow-query { any; };
In the listen-on line, after localhost, specify the DNS IP address. This is the IP on which the host will accept queries. Use any to listen on all addresses.
In the allow-query line, define query permissions. any allows queries from everyone. You can also restrict it to a specific subnet, e.g., 192.172.160.0/24.
Apply the config:
systemctl restart named
Global Options
Besides the basics, you can fine-tune the server using other global parameters:
Argument
What It Configures
directory
Working directory (default is /var/named if not specified)
forwarders
IPs to forward unresolved queries to (e.g., Google's DNS)
forwarders { 8.8.8.8; 8.8.4.4; };
forward
Options: FIRST or ONLY. FIRST tries forwarders first, then internal. ONLY skips internal search.
listen-on
Interfaces that BIND listens on (usually port 53 UDP)
allow-transfer
Hosts allowed for zone transfers
allow-query
Who is allowed to send DNS queries
allow-notify
Hosts allowed to receive zone change notifications
allow-recursion
Hosts that can make recursive queries. Default is unrestricted.
Testing
To check if the DNS server accepts queries from clients, use the nslookup utility.
From another computer:
nslookup site-example.com 192.172.160.14
This checks the IP address of site-example.com using DNS server 192.172.160.14.
Alternatively, use dig:
dig @192.172.160.14 site-example.com
It works similarly, just a different syntax.
BIND Zones
Basic DNS server setup is complete. Now, let’s talk about usage. For that, you configure zones:
Primary zone – You create and edit domain records directly on this host.
Secondary zone – This host pulls data from a primary DNS server.
Stub zone – Stores only NS records used for redirection.
Caching-only zone – Doesn’t store records; only caches query results for performance.
Zone management is handled in the config file and is a larger topic. Creating your own zone lets you assign friendly names to each host, which is helpful when dealing with many nodes instead of using IPs.
10 April 2025 · 4 min to read
Linux
Linux Keyboard Shortcuts: Top Combinations for Users
Keyboard shortcuts in Linux are a great tool that can help you work more efficiently. Instead of using the mouse and navigating the menus, you can often press a couple of buttons to get you to the same result much quicker.
Linux operating systems support a wide range of these shortcuts, or hotkeys. It’s important to note that each OS can have specific hotkeys that might not work in other distributions. However, you can fix that as users can add new or modify existing combinations in their system settings.
In this article, we will cover universal key combinations that are universal across different desktop environments. Most of the Linux hotkeys we examine are focused on working with the terminal.
The commands in this article sometimes use the Super key, which corresponds to the Windows key in Windows OS or the Cmd key in macOS. For example, the shortcut to switch keyboard layouts Super + Space in Linux is similar to Windows + Space or Cmd + Space.
Basic Linux Shortcuts
Let’s start with basic general-purpose shortcuts. They help perform repetitive tasks more quickly.
Alt + Tab or Super + Tab: Switches between windows. Similar to the function in Windows and other OSes.
Super + Space: Switches between multiple keyboard layouts.
Super + A: Opens the applications menu (usually located in the bottom left corner).
F2: Used to rename files. Navigate to the file, click it once, then press F2 to rename.
Ctrl + Alt + T: One of the most important and popular Linux shortcuts that opens the terminal window.
Alt + F2: Opens a command prompt window in the center of the screen, where you can run a command or open a program.
Super + D: Minimizes all windows to show the desktop.
Ctrl + Alt + Del: Brings up a prompt with “Cancel” and “Log Out” options. The system logs out automatically if no selection is made within 60 seconds.
These combinations help any specialist work more efficiently in Linux. But let’s move on to the more useful terminal-related hotkeys.
Linux Terminal Shortcuts
The terminal in Linux is the primary tool for interacting with the command shell. Below are terminal hotkeys that will help you work more efficiently.
Terminal Window Management
These shortcuts help open, switch, and close terminal tabs and windows quickly:
Ctrl + Shift + Q: Completely closes the terminal window.
Ctrl + Shift + T: Opens a new terminal tab.
Ctrl + Shift + W: Closes the current terminal tab (or window if only one tab is open).
Ctrl + Shift + D: Detaches the terminal tab into a separate window.
Ctrl + PgUp / PgDown: Switches between terminal tabs (previous/next).
Cursor Movement in a Line
Linux users primarily use the keyboard in the terminal. To avoid switching to the mouse, here are some shortcuts for faster cursor navigation:
Ctrl + A (or Home): Moves the cursor to the beginning of the line.
Ctrl + E (or End): Moves the cursor to the end of the line.
Ctrl + XX: Quickly moves the cursor to the beginning of the line; using it again returns it to the original position.
Ctrl + → / ← or Alt + F / B: The first pair moves the cursor one word forward or backward. The second pair does the same using the Alt key.
Input and Editing
In addition to quickly moving the cursor along the line, you can also simplify input and editing of commands.
TAB: One of the main hotkeys in the Linux terminal, used for auto-completing commands or file paths. Pressing once completes the command; pressing twice suggests multiple completion options if available.
Ctrl + T: Swaps the last two characters before the cursor.
Alt + T: Similar to the previous shortcut but swaps the last two words before the cursor.
Alt + Backspace: Deletes the word before the cursor.
Alt + D: Deletes all characters after the cursor up to the next space.
Alt + U / Alt + L: The first changes all characters to the right of the cursor to uppercase; the second to lowercase.
Clipboard Operations
These shortcuts allow interaction with the clipboard in the terminal: copying, cutting, or pasting parts of a line or the entire line.
Ctrl + W: Deletes the word before the cursor.
Ctrl + U: Deletes everything from the cursor to the beginning of the line.
Ctrl + K: Deletes everything from the cursor to the end of the line.
Ctrl + Y: Pastes the last deleted text from the clipboard using one of the three commands above.
Command History Navigation
Hotkeys also help interact with the command history in the terminal. This is useful when searching for previously used commands.
To view the list of executed commands, use:
history
To quickly find and execute a previously used command, use the shortcuts below:
Ctrl + R: Opens a search prompt to find a previously used command. Press Enter to run it, or Esc to edit or exit.
Ctrl + O: Executes the command found using the shortcut above.
Alt + <: Loads the first command from the command history.
Screen Output Management
The following shortcuts control the amount of information displayed in the terminal window and help focus on specific data even during a running process.
Ctrl + C: Sends the SIGINT signal to the active process, immediately interrupting it.
Ctrl + D: An alternative to exit, used to close the terminal. Often used in SSH sessions to disconnect from a remote host.
Ctrl + Z: Suspends the active process and sends it to the background. Use the fg command to bring it back. Use jobs to list background processes.
Ctrl + L: An alternative to the clear command, clears the terminal screen.
Ctrl + S / Ctrl + Q: Ctrl + S pauses the terminal output; Ctrl + Q resumes it. Useful for stopping the screen output temporarily to examine or copy information.
Adding and Modifying Hotkeys
A Linux user may find that some combinations do not work or are missing entirely. Hotkeys may differ depending on the distribution as each system includes a default list of predefined shortcuts. However, in most Linux environments, users can create new shortcuts or modify existing ones.
Use Super + A to open the application menu.
Use the search bar to find and open Settings.
In the opened window, find and go to the Devices tab.
Go to the Keyboard section. On the right side, a list of default hotkeys will appear.
Click on any command to open the editing window and assign a new shortcut.
If the desired command is not listed, you can add a custom one by clicking the + at the bottom. Enter its name, the command to execute, and the key combination.
Conclusion
This article reviewed the main Linux hotkeys that simplify and speed up user workflow. It’s important to note that this is not a complete list. In addition to those listed, there are other combinations that cover different functionalities in Linux distributions.
09 April 2025 · 6 min to read
Do you have questions,
comments, or concerns?
Our professionals are available to assist you at any moment,
whether you need help or are just unsure of where to start.
whether you need help or are just unsure of where to start.
