Learn touch Command in Linux with Examples

The touch command in Linux is one of those tools that looks too simple at first glance.However, it becomes an essential part of day-to-day administration in shell scripts, cron jobs, CI/CD pipelines, Docker builds, and log rotation workflows. This article provides detailed information on all aspects of using the touch command in Linux, including practical examples that reflect real-world tasks performed by system administrators.

As its core, touch command performs only two functions; it creates an empty file (or overwrites an existing file), and it updates the timestamp of a file. While these two features may seem to have limited functionality, they give touch incredible flexibility when used in automated or scripted workflow.

Examples

The touch command is a standard Unix/Linux utility that belongs to the GNU Core Utilities package. Its primary job is to update the access and modification timestamps of a file to the current time. If the file does not exist, touch creates it as an empty file.

This behavior makes it useful in two completely different scenarios. First, when you need a placeholder file quickly without writing any content into it. Second, when a script or build system depends on a file's timestamp to decide whether to reprocess something touch lets you manually trigger that logic.

Every file on a Linux system carries three timestamp values:

• atime - the last time the file was accessed or read
• mtime - the last time the file's content was modified
• ctime - the last time the file's metadata or content changed

touch can update any of these independently, or set them to a custom date and time you define. This level of control is what makes it genuinely useful beyond just "creating blank files." If you are new to Linux, it helps to first get comfortable with basic Linux commands before diving into timestamp management.

You can pass one or more filenames after the options. When multiple filenames are given, touch processes all of them in sequence. Options let you control which timestamp gets updated, what value it gets set to, and whether to avoid creating a new file if it does not already exist.

This is the most basic Linux touch command example. If the file does not exist, touch creates it as an empty file with zero bytes. If it already exists, touch updates its timestamps without changing any content inside it.

Verify the file was created:

You can pass several filenames in one command. This is one of the most practical Linux touch command examples for anyone setting up a project structure quickly without writing a separate create command for each file.

Sometimes you only want to update a timestamp if a file already exists. You do not want touch to accidentally create a file you did not intend to make. The -c flag handles that cleanly.

The -a flag changes only the atime of a file. This is helpful when you want to simulate a file being read without changing its modification time. Build systems and backup tools often check mtime specifically, so keeping it untouched can matter a lot in automated workflows.

Confirm the access time updated using the --time=atime flag:

The -m flag updates only the mtime. This is useful when you want a build tool or deployment script to think a file was recently modified, triggering a rebuild without actually editing any content inside the file.

Check the full timestamp details with stat to confirm mtime was updated:

The -t flag lets you set a specific timestamp instead of using the current system time. The format is [[CC]YY]MMDDhhmm[.ss] year, month, day, hour, minute, and optionally seconds. This is commonly used in testing, data migration, and log replay scenarios.

The -d flag accepts a natural date string that is easier to read and write than the -t format. This is often preferred in scripts where clarity matters more than strict format compliance.

The -r flag copies the timestamp from a reference file. This is very useful in backup and restore scripts where you want a restored file to carry the same timestamp as the original, making audits and comparisons straightforward.

Brace expansion in bash combined with touch is a fast way to generate many files at once. This technique is regularly used when setting up test environments, preparing log rotation directories, or scaffolding a new project layout without writing loops.

In bash scripting and automation workflows, touch is commonly used to create lock files, flag files, and job status markers. These files signal to other processes whether a job is already running, completed, or failed a simple but reliable coordination mechanism.

When setting up cron job based log rotation or CI/CD pipelines, placeholder files often need to exist before the actual process starts writing into them. Many tools check for the file's existence before they launch. touch handles this with zero overhead.

Inside Docker containers and container initialization scripts, touch is used to create PID files, ready-state markers, and lock files. Kubernetes health probes and orchestration systems can check for these files to confirm a container is fully initialized and ready to serve traffic.

Most errors with touch come from filesystem permissions or path issues. Here are the ones you will run into most often and how to handle them without guessing.

This happens when you try to create or update a file in a directory where your user does not have write permission.

Fix: Use sudo if you have the privilege, or adjust directory permissions using the chmod command in Linux to grant write access to your user account.

This error appears when the parent directory in the path does not exist yet. touch will not create intermediate directories on its own.

Fix: Create the full directory path first with mkdir -p, then run touch.

This typically happens on mounted ISO images, read-only NFS shares, or systems booted into recovery mode. The filesystem itself blocks all write operations.

Fix: Remount the filesystem with write access if appropriate, or do your work in a writable location like /tmp.

On systems running SELinux in enforcing mode, which is the default on RHEL and Rocky Linux, touch may be blocked from creating files in certain directories even when standard Unix permissions look correct. The error message looks exactly like a standard permission denied error, which makes it tricky to diagnose without checking the audit log.

Fix: Check the SELinux audit log and restore the correct file context using restorecon.

One of the best things about touch is that it works exactly the same way across all major Linux distributions. Whether you are on Ubuntu 24.04, RHEL 9, Rocky Linux 9, AlmaLinux, Debian, or any other mainstream distribution, the syntax, flags, and behavior are identical. There is nothing distro-specific to learn or worry about.

touch is part of the GNU Core Utilities package, which is installed by default on every major Linux distribution. You do not need to install anything extra. It is available the moment you open a terminal on any of these systems.

In enterprise environments on RHEL and Rocky Linux, touch is commonly used inside systemd service unit ExecStartPre hooks to create run directories and PID file placeholders before a service process starts. On Ubuntu-based servers, it shows up regularly in deployment scripts managed by tools like Fabric, Capistrano, and Ansible. Ansible playbooks often use touch via the file module or shell tasks to create marker files that track provisioning state across server fleets.

For full reference on all available options and edge case behavior, the GNU Coreutils official documentation is the authoritative source that covers the complete specification.

Several Linux commands can produce an empty or new file, but they work differently. Knowing which one to use depends on what you actually need from the operation. You can also check the dedicated guide on the cat command in Linux and the echo command in Linux to understand how each one handles file creation differently.

The touch command is one of those utilities that keeps appearing in real infrastructure work. It is not flashy, but it solves specific problems cleanly. Creating placeholder files, managing lock mechanisms, setting up log directories before a service starts, signaling job completion in shell pipelines touch handles all of these with no overhead and no dependencies.

In automation and scripting, file existence and file timestamps are real control signals. Tools like make, rsync, and various backup utilities make important decisions based on these values. Being able to manipulate them directly with a single command is genuinely useful for a sysadmin or DevOps engineer working with real systems.

The fact that it works identically across Ubuntu, RHEL, Rocky Linux, Debian, and every other major distribution means you can write scripts that rely on touch without worrying about portability at all. It is always there, always behaves the same way, and never needs to be installed separately. For something that does so little on the surface, it earns its place in a lot of important workflows.