Learn Linux commands
by actually typing them.

List the contents of a directory, with options for hidden files, long format, sorting and more.

Move between directories: absolute and relative paths, home shortcut, and jumping back.

Show the absolute path of the directory you are currently in.

Create one or many directories, including whole nested paths with -p.

Create empty files instantly, or update the timestamps of existing ones.

Delete files and directories — and understand -r, -f and why there is no trash bin.

Copy files and whole directory trees, preserving attributes when needed.

Move files between directories and rename them — the same operation in Linux.

Print file contents, number lines, and join multiple files together.

Find lines matching a pattern in files or piped input — the workhorse of text search.

Locate files anywhere in a directory tree by name, type, size, date — and act on them.

Change file permissions with numeric (755, 644) and symbolic (u+x) modes — clearly explained.

Print text and variables, and write or append to files with > and >>.

Print the first or last lines of a file — including live log following with tail -f.

Create and extract archives: tar.gz, tar.bz2 — with the flag combinations finally explained.

Log into remote machines, run remote commands, use keys instead of passwords, and tunnel ports.

Download files, test APIs, send POST requests with JSON, and inspect headers.

Download files and whole sites, resume interrupted transfers, and fetch in the background.

See what is running, find a process ID, and combine with grep to hunt down a program.

Terminate processes politely or forcibly — and understand what -9 really does.

See free space per filesystem and find what is eating your disk, directory by directory.

Make one file reachable from several paths — and understand symlinks vs hard links.

Stream-edit text: substitute, delete lines, and edit files in place with -i.

Pull columns out of any output, filter rows, and compute sums — the shell's spreadsheet.

Slice fields or character ranges out of each line — quick column extraction for delimited data.

Turn a list of items into command arguments — the glue between pipelines and commands.

Assign files to users and groups — the other half of Linux permissions.

List, search and re-run previous commands — plus Ctrl+R, !! and the tricks that save hours.

Check whether a host is reachable and measure round-trip latency.

The modern tool for addresses, links and routes — replacing ifconfig and route.

See listening ports, active connections and which process owns each socket.

Ask DNS questions directly: A, MX, TXT records, and which server answered.

Sync directories locally or over SSH, transferring only what changed.

The quickest way to move a file to or from a remote machine.

The live dashboard: CPU, memory, load average and the processes consuming them.

RAM and swap at a glance — and how to read "available" correctly.

Start, stop, enable and inspect services — the control panel of modern Linux.

Query the system journal: by service, time window, priority — and follow live.

Temporary privilege, audited — and why sudo won everywhere.

Search, install, upgrade and remove packages — plus the dnf/pacman equivalents.

Run commands on a schedule — and read the five-field syntax fluently.

Split a stream: watch output live while saving a copy — and write files with sudo.

Character-level transforms in pipelines: case, delete, squeeze, sanitize.

Deduplicate adjacent lines and count occurrences — sort's inseparable partner.

See exactly what changed between two files or trees — the language of patches.

The standard pager: scroll, search, jump — and follow logs from inside.

Single-file compression (gzip family) vs portable archives (zip) — and when each.

How configuration flows into processes — PATH, export, and why edits "don't stick".

Name your habits: shortcuts, safer defaults, and where to keep them.

Run things in the background, juggle them, and keep them alive after logout.

Fingerprint files, verify downloads, and prove two files are identical.

Which binary actually runs when you type a name — and unmask aliases.

The 15 commands that cover 90% of daily use, in learning order.

rwxr-xr-x, 755 vs 644, chown — the model behind the numbers.

stdin, stdout, stderr and composing commands into pipelines.

Variables, conditions, loops and exit codes — your first automation.

What /etc, /var, /usr and /proc are for, and where to look when things break.

See how much space is left, and find out what is using it.

Unpack tar.gz, tar.bz2, tar.xz and zip archives from the command line.

Find which process holds a port and stop it cleanly.

Replace text in one file or across a whole project, safely.

Give a script permission to run, and understand why it needs it.

Find which files contain a word, and exactly where.

SSH rejected your login because no key you offered was accepted by the server.

The shell searched every directory in your PATH and found no executable with that name.

The path you gave does not resolve — but often the missing part is not the one you think.

The path resolves fine — the system simply will not let you do that with it.

A filesystem is full — confirm which one, and whether you ran out of bytes or inodes.

Something is already listening on the port your program wants.

Both copy files over SSH. rsync sends only what changed; scp sends everything, every time.

curl is an HTTP client for talking to services; wget is a downloader for retrieving files.

sed edits lines; awk understands columns. Substitution is sed, computation is awk.

A symlink stores a path and can break; a hard link is a second real name for the same file.

grep is everywhere; ripgrep is dramatically faster on code and respects .gitignore by default.

tar.gz compresses better and preserves Unix permissions; zip opens with a double click on any system.