What Is Linux Touch Command + Practical Usage Examples

The Linux touch command is the quick-and-reliable way to create files and change timestamps. It’s small, fast, and shows up everywhere—from shell scripts and build systems to quick log and artifact management.

This guide breaks down what touch does, how it interacts with file access/modification times, and when each option is the right tool. You’ll also get practical examples you can paste into your terminal and adapt to your workflow.

As an Amazon Associate I earn from qualifying purchases.

What the Linux touch Command Does

touch has two main jobs:

• Create an empty file if the target file doesn’t exist.
• Update timestamps on existing files—by default, it updates the modification time (mtime) to the current time (and often also impacts access time depending on flags and filesystem behavior).

In practice, that makes touch useful for “marking” a file as recently changed, forcing rebuilds in some workflows, or initializing placeholder files before writing content.

How touch Works Under the Hood

Every regular file typically has timestamps such as:

• atime: last access time (read)
• mtime: last modification time (content changes)
• ctime: inode metadata change time (permissions, ownership, renames, etc.)

touch primarily manipulates atime and mtime. The exact behavior can vary based on how your system and filesystem handle atime updates (many Linux setups mount filesystems with relatime or similar settings to reduce atime writes).

When you run touch somefile on an existing file, you’re not changing contents—you’re updating timestamps. That’s why it’s common in build tools and scripts that decide whether work needs to run.

Syntax and Core Options

The general form is:

touch [OPTION]... FILE...

Commonly used options you’ll see in scripts:

Option	What it does
-a	Change access time (atime) only
-m	Change modification time (mtime) only
-c or --no-create	Don’t create the file if it doesn’t exist
-t [[CC]YY]MMDDhhmm[.ss]	Set timestamp using a specific format
-d DATE	Parse a human-readable date string and set it
-r FILE	Use the timestamps of another file
-h	On some implementations: affect the symbolic link itself (not the target)

Available flags can vary slightly across implementations. On most mainstream Linux distros, touch is provided by GNU coreutils and supports the options above.

Practical Usage Examples

Below are real-world, paste-ready examples. To verify results, you can inspect timestamps with stat or ls --time.

Example verification command:

stat -c '%n %x %y' yourfile

Create an empty file

If the file doesn’t exist, touch creates it as an empty file (size 0 bytes):

touch placeholder.txt

To confirm:

ls -l placeholder.txt

Update modification time (mtime) to now

The default behavior updates timestamps to the current time. For mtime specifically, the clearest explicit command is:

touch -m report.log

Use this when you want the file to look “new” for tools that check modification times.

Update access time (atime) to now

If you care about access time (atime) rather than modification time:

touch -a document.pdf

Note that atime behavior can be influenced by mount options such as relatime.

Set a specific timestamp (YYYY-MM-DD or full date-time)

GNU touch supports human-readable dates via -d:

touch -d '2026-05-01 09:30:00' report.log

You can also use relative times:

touch -d '2 days ago' report.log

Set timestamps using epoch seconds

If you have a Unix epoch value (seconds since 1970-01-01), convert it into a format touch can parse or pass directly using supported formats.

Common pattern:

touch -d '@1714500000' report.log

The @ tells many GNU utilities to interpret the value as epoch seconds.

Create a file only if it does not exist

There’s no direct “create-if-missing, don’t update timestamps otherwise” switch, but you can achieve the goal with a conditional:

[ -e config.env ] || touch config.env

If you also want to avoid errors when permissions are restricted, keep the test and touch separate like above.

Update timestamp on multiple files at once

touch accepts multiple filenames in a single command:

touch src/*.c

Be mindful: if the glob matches nothing, some shells leave the literal pattern unchanged. To avoid surprises, consider enabling nullglob behavior or using safer wrappers in scripts.

Touch with a pattern via the shell

For example, create/update timestamp for all JSON files in a folder:

touch -m *.json

If a folder might be empty, you can add a guard:

compgen -G '.json' > /dev/null && touch -m .json

compgen checks whether the glob expands without creating files.

Use touch for batch workflows (build artifacts, logs)

Make a “build stamp” file that other parts of your automation check:

touch build.stamp

Then your scripts can compare build.stamp against source files using find or timestamp comparisons.

Example: run a command only when sources are newer than the stamp:

find src -type f -newer build.stamp -print -quit | grep -q . && make

Use -r to copy timestamps from another file

You can copy both access and modification times from a reference file:

touch -r reference.txt cloned.txt

This is handy when you’re syncing directory structures, creating backups, or preserving metadata-like behavior in workflows.

Choosing the Right Flags (Common Recipes)

Most real tasks boil down to a few patterns. Here are the ones you’ll use most frequently.

“Create missing file, otherwise update mtime”

Default touch behavior is already close:

touch cache.db

On missing file, it creates. On existing, it updates timestamps to now.

“Only update mtime; never create”

Use -m plus -c:

touch -c -m config.yml

If config.yml doesn’t exist, touch does nothing.

“Set a timestamp and create if missing”

Use -d (or -t) without -c:

touch -d '2026-05-13 00:00:00' archive.zip

“Copy timestamps from another file”

touch -r master.dat follower.dat

“Set atime only (rare, but sometimes needed)”

touch -a -d '2026-05-01 09:30:00' /var/cache/index

If your filesystem mount prevents atime updates, you might not see atime change with stat.

Common Mistakes and Gotchas

• Confusing mtime with atime: tools that rebuild often rely on mtime, not atime. Use -m when you mean it.
• Assuming timestamps always change: some filesystems or mount options may limit atime updates. Modification time changes are usually reliable for regular files.
• Using -t format incorrectly: -t [[CC]YY]MMDDhhmm[.ss] is strict. If your string doesn’t match, the command can error or interpret values unexpectedly.
• Touching symlinks when you meant targets: depending on your touch implementation and platform, behavior may differ for symbolic links. If you need deterministic behavior, test on your system or use readlink/stat to confirm.
• Globs that match nothing: touch *.log can behave unexpectedly if there are no matches (the literal pattern might be passed). Add guards in scripts.
• Permissions: creating or updating timestamps requires appropriate permissions. Without write permission on the directory or the file itself, touch fails.

Troubleshooting touch Failures

When touch doesn’t behave as expected, here’s what to check in order.

“Permission denied”

If you see an error like touch: cannot touch 'file': Permission denied, check:

• You have write permission on the directory for creating files.
• You have permission to modify metadata for existing files.
• The filesystem is mounted read-only (try mount | grep ' / ' or check dmesg for errors).

Timestamp didn’t change

Verify what timestamp actually changed:

stat -c '%n atime=%x mtime=%y' yourfile

Then check these typical causes:

• atime limited by mount options: relatime may prevent atime from updating on every access.
• touch ran on a different path: shell expansions or symlinks may lead to a target you didn’t expect.
• Sub-second precision differences: some tools show timestamps with limited precision. If you set a timestamp equal to the existing value, changes might not be visible.

Command errors with -t

If touch -t fails, re-check your format. For example, to set May 13, 2026 at 14:05:30:

touch -t 202605131405.30 file.txt

Make sure the digits match CCYYMMDDhhmm[.ss] exactly.

“No such file or directory” when using globs

This often means the glob didn’t match and is being treated as a literal argument, or you’re referencing a missing directory. In scripts, use a guard before touching:

shopt -s nullglob; files=(/path/*.log); (( ${#files[@]} )) && touch -m "${files[@]}"

This is a bash approach; adapt for your shell.

Checking your touch version (behavior differences)

GNU coreutils touch has long been stable, but different environments (BusyBox, BSD variants) can differ. Check:

touch --version

If you don’t have a version flag, use which touch and verify the package providing it.

Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Support on Ko-Fi

touch vs Alternatives (stat, time, printf, cp, install)

touch is a timestamp tool, not a content tool. Here’s when alternatives make more sense.

Use stat for inspection, not modification

stat shows timestamps so you can confirm your changes:

stat -c '%n %x %y %z' file

touch changes timestamps; stat helps you validate.

Use printf or echo for content changes

If you need to create a file and write content (which will update mtime), do this instead:

printf '%s

' 'hello' > file.txt

That changes file size and content, which many workflows care about more than timestamps alone.

Use cp -p for copying metadata (when you actually want preservation)

If your goal is to duplicate a file while preserving timestamps, prefer:

cp -p source.txt dest.txt

touch won’t copy file content; it only updates timestamps.

Use install for setting permissions plus creation

When you need to create a file and set mode/ownership atomically (common in system scripts):

install -m 0644 /path/template.conf /etc/app.conf

Then timestamps and permissions are set as part of the installation step.

FAQ: touch Command

Does touch change the file size?

No. If the file exists, touch doesn’t alter content, so size stays the same. If it creates a new file, that file starts at 0 bytes.

Why do I see atime not changing?

Many Linux systems mount filesystems with policies like relatime to reduce atime updates. This can make atime changes less frequent or dependent on other timing rules.

Can touch update multiple timestamp fields at once?

Yes. The default behavior typically updates both access and modification times unless you restrict it with -a or -m. For precision, use -a or -m.

How do I set the timestamp to exactly now but keep formatting consistent?

Use relative time strings or omit -d entirely. For example, touch file sets timestamps to the current time in the implementation’s default way.

Is touch safe to use in scripts?

Yes, with standard precautions: quote filenames, guard globs, and handle permissions. When you’re using -d with user input, validate dates or restrict allowed formats to avoid surprising results.

What’s the difference between touch and changing timestamps with chmod/chown?

chmod and chown change metadata, which can update ctime. touch updates atime and/or mtime. They’re related but not the same.

Bottom Line

touch is the go-to Linux command for creating files and changing timestamps with minimal fuss. Once you understand which timestamp you’re changing (-a, -m, or defaults) and how your filesystem treats atime, it becomes a reliable tool in both interactive work and automation.

Use -c to avoid accidental creation, -d or -t to set precise times, and -r when you want timestamp cloning from a reference file.

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.