Archiving & Compression: tar, gzip & the .tar.gz Workflow

Whenever you download source code, move a project between machines, or make a backup, you meet a file like project.tar.gz. Understanding it comes down to seeing that two separate jobs are happening:

• Bundling — packing a whole directory tree (many files and folders) into a single file called an archive. On Unix this is `tar`'s job. Historically the name means tape archive, but today it's how you turn a folder into one movable file.
• Compressing — making that file smaller by squeezing out redundancy. That's a compressor like `gzip`, bzip2, or xz.

These are independent. tar by itself bundles but does not shrink — a plain .tar is often about the same size as the files inside. A compressor by itself shrinks a single file but can't bundle a directory. The everyday .tar.gz (also written .tgz) is simply both, in order: tar bundles the tree into one .tar, then gzip compresses that into .tar.gz. The double extension literally tells you the two steps.

This is why you can't just "zip a folder" with gzip alone on Linux the way you might on other systems — gzip compresses one file at a time. You bundle first with tar, then compress. tar knows how to do both in a single command, which is what makes it the tool everyone reaches for.

tar has three main modes, and you pick exactly one each time:

• `-c` — create a new archive from files.
• `-t` — list (the table of contents) — show what's inside without unpacking.
• `-x` — extract — unpack the contents back out.

Every one of these is paired with `-f FILE`, which names the archive file to read or write. -f is not optional in practice — it tells tar the archive is a file (not a tape). A useful memory aid: `-f` comes last among the clustered letters because the filename follows it.

Two more letters you'll add constantly:

• `-v` — verbose: print each file as it's processed, so you can see what happened.
• `-z` — run the archive through gzip (covered next).

So the two commands you'll type most are tar -czf name.tar.gz dir/ to make an archive and tar -xzf name.tar.gz to unpack one. Read -czf as "create, gzip, into this file", and -xzf as "extract, un-gzip, from this file".

To compress while archiving, add one compressor letter. tar runs the archive through that compressor on the way out (and reverses it on the way in):

• `-z` → gzip → .tar.gz / .tgz. Fast, everywhere, moderate compression. The safe default.
• `-j` → bzip2 → .tar.bz2. Slower, smaller than gzip.
• `-J` (capital) → xz → .tar.xz. Slowest, usually the smallest. Common for source releases and kernels.

The tradeoff is speed versus size: gzip is quick and good enough for most day-to-day use; xz squeezes hardest but takes longer and more memory. Match the tool to the goal — gzip for a quick transfer, xz when the download size really matters. (Newer systems also have zstd via --zstd / .tar.zst, which gets near-xz ratios at gzip-like speed.)

The golden rule: extract with the same letter you created with, or just let tar autodetect. Modern GNU tar can usually figure out the compressor from the file on extract, so tar -xf archive.tar.xz often works without -J — but being explicit never hurts.

Standalone, `gzip file` compresses a single file to file.gz (replacing the original), and `gunzip file.gz` reverses it. That's for one file; for a directory you still bundle with tar first.

Extraction unpacks files into your current directory — which is where two classic surprises come from:

• A tarbomb: an archive whose files are not inside a single top folder, so extracting it dumps dozens of loose files right into your current directory, mixed in with everything else.
• Where things land: tar -x writes relative to where you're standing, so running it in your home directory scatters the contents there.

Two habits prevent both:

1. List before you extract — tar -tf archive.tar.gz. If everything is under one top-level directory (e.g. project/…), it's tidy. If you see loose files at the top, it's a tarbomb — make a directory to catch them.

2. Extract into a directory you control — either cd into a fresh empty directory first, or use `-C DIR` to tell tar where to unpack: tar -xzf archive.tar.gz -C /tmp/unpack. The directory must already exist.

One more caution: only extract archives you trust. A malicious archive can contain absolute paths or .. entries that try to write outside the target. GNU tar strips a leading / by default, but the safe move with anything unfamiliar is to list it first and unpack into a throwaway directory.

One continuous experiment: build a small tree, bundle-and-compress it, peek inside without unpacking, then extract it into a clean directory and confirm it round-tripped.