All shell commands

PowerShell's append-to-file cmdlet — the equivalent of bash `>>` redirection that adds content to the end of an existing file.

Strip the directory part of a path, leaving only the final filename component.

Print file contents to standard output.

POSIX way to test whether a command exists and where it resolves.

PowerShell's copy cmdlet — the cp equivalent.

Copy files and directories.

Copy and convert files at the block level — used for disk imaging, raw I/O, and filling test files.

Report mounted-filesystem free space and inode usage.

Strip the final filename component from a path, leaving only the directory part.

Summarize disk usage of files and directories.

Identify a file by its magic bytes, not its extension.

Locate files by name, size, time, or other attributes.

PowerShell's directory-listing cmdlet — the ls equivalent.

PowerShell's command-introspection cmdlet — the which / type / command -v equivalent that returns rich CommandInfo objects.

PowerShell's file-read cmdlet — the cat / tail equivalent.

PowerShell's current-directory cmdlet — the pwd equivalent that returns a structured PathInfo object.

Page through a file with backward navigation and search.

Create a hard link or symbolic link to a file or directory.

List directory contents.

List block devices (disks, partitions, LVM volumes, RAID arrays) as a tree showing size, mountpoint, and filesystem.

Print an MD5 hash of one or more files. Cryptographically broken — integrity-only.

Create a new directory.

Create a uniquely-named temporary file (or directory) in a race-free way.

View a file one screen at a time (basic pager).

Attach a filesystem (disk, image, network share) to a directory in the tree so its contents become accessible.

PowerShell's move/rename cmdlet — the mv equivalent.

Move or rename files and directories.

PowerShell's create-file/directory cmdlet — like touch + mkdir.

PowerShell's pipeline-to-file cmdlet — the equivalent of bash `>` redirection that writes formatted text output to a file.

Print the target of a symbolic link, or the canonical path.

Resolve a path to its absolute, canonical form.

PowerShell's delete cmdlet — the rm / rmdir / del equivalent.

PowerShell's path-canonicalize cmdlet — the realpath equivalent.

Delete files and directories.

PowerShell's verbatim file-writer cmdlet — the equivalent of bash `>` that overwrites a file with raw, unformatted content.

PowerShell's working-directory cmdlet — the cd equivalent that also navigates registry and other PowerShell providers.

Print a SHA-1 hash of one or more files. Cryptographically broken — integrity-only.

Print a SHA-256 hash of one or more files.

Print a SHA-512 hash of one or more files — 128 hex chars, current best-practice for high-stakes integrity.

BSD/macOS Perl wrapper that computes SHA-1 through SHA-512 hashes of files.

Print a file's size, mode, owner, and timestamps.

PowerShell's path-existence cmdlet — the bash [ -e ] equivalent.

Create an empty file or update its modification time if it exists.

Print a directory tree showing files and subdirectories.

Show how a name is interpreted — builtin, function, alias, or file.

Detach a previously mounted filesystem from its directory in the tree, flushing pending writes first.

Locate the binary, source, and manual page for a command.

Locate an executable in PATH and print its full path.

Pattern scanning and processing language for structured text.

Arbitrary-precision command-line calculator that evaluates an expression and prints the result.

Byte-by-byte comparison of two files — the binary counterpart to diff.

Format whitespace- or delimiter-separated input into aligned columns.

Compare two SORTED files line by line, emitting three columns: only-in-file1, only-in-file2, in-both.

PowerShell's set-difference cmdlet — the diff equivalent for comparing two collections of objects or text.

Parse a JSON string into PowerShell objects you can pipe and filter.

Serialise a PowerShell object graph to a JSON string.

Extract sections (fields or characters) from each line.

Compare two files or directories line-by-line and report the differences.

Print arguments to standard output, separated by spaces, followed by a newline.

Write PowerShell objects to a CSV file with a header row.

Search file contents for a pattern.

PowerShell's grouping cmdlet — the `sort | uniq -c` equivalent that buckets items by a property and returns counts plus the underlying groups.

Output the first lines of a file.

BSD-style hexadecimal dump — flexible format strings for byte-level inspection.

Convert text between character encodings (UTF-8, UTF-16, Latin-1, GBK, …) with optional transliteration.

Read a CSV file into PowerShell objects, inferring property names from the header row.

Command-line JSON processor — filter, transform, and build JSON from the shell.

PowerShell's aggregation cmdlet — counts items and computes sum/min/max/average, similar to wc plus awk arithmetic.

Number the lines of a file (or stdin), emitting line numbers followed by each line.

Dump file contents in octal, hexadecimal, decimal, or character form — for binary inspection.

Merge corresponding lines of two or more files side-by-side, tab-separated by default.

Apply a unified diff to source files, transforming them in place.

Stream editor for filtering and transforming text.

PowerShell's projection cmdlet — picks specific properties or the first/last N objects, like cut + head + tail combined.

PowerShell's pattern-search cmdlet — the grep equivalent.

Generate an arithmetic sequence of numbers (1, 2, 3, … N) — one per line by default.

Sort lines of text.

PowerShell's sort cmdlet — sorts pipeline objects by one or more properties.

Split a large file into smaller chunks by line count, byte size, or chunk count.

Extract printable ASCII (and optionally UTF-16) sequences from binary files.

Concatenate and print files in reverse line order.

Output the last lines of a file.

Read stdin and write to both stdout and one or more files at once.

Translate or delete characters from input.

Filter adjacent duplicate lines.

Count lines, words, or bytes.

PowerShell's pipeline filter cmdlet — the awk/grep equivalent for filtering objects by property.

PowerShell's host-UI writer — the coloured-banner echo that bypasses the pipeline and prints directly to the terminal.

PowerShell's pipeline-emitter cmdlet — the echo equivalent that sends objects, not just text, down the pipeline.

Build and execute command lines from standard input.

Parse, validate, and query XML documents on the command line — from the libxml2 project. XPath queries, DTD/XSD validation, pretty-printing, and XInclude resolution.

Hexadecimal dump utility — show file contents as hex bytes plus ASCII gutter.

Emit a string (default "y") repeatedly until killed — used to auto-confirm interactive prompts.

Query, transform, and edit YAML, JSON, TOML, and XML on the command line — the jq-shaped tool for non-JSON config formats. TWO competing implementations: mikefarah/yq (Go, jq-syntax-compatible) and kislyuk/yq (Python, jq-wrapper).

Create a shortcut name for a longer command line.

Install, upgrade, and remove packages on Debian / Ubuntu / Mint via the APT package manager — the canonical "install software" command for Debian-family Linux.

History expansion `!!` — repeat the previous command.

History expansion `!$` — last argument of the previous command.

Exit the innermost (or N-th enclosing) loop.

Install, upgrade, and remove packages on macOS (and Linux) via Homebrew — the de-facto macOS package manager, also installable as Linuxbrew on Debian / RHEL.

PowerShell's terminal-clearing cmdlet — the clear / cls equivalent that wipes the visible scrollback.

Skip to the next iteration of the innermost (or N-th enclosing) loop.

Print the current date and time, or format an arbitrary date — the surface you reach for to timestamp logs, name backup files, or compute "now minus N days".

Declare a variable, an array, or set variable attributes.

Generate ncurses-style TUI widgets (menus, prompts, checkboxes, gauges, password fields) from shell scripts — capture user input as exit-code + stderr text.

[[ ]] extended test in bash/zsh with regex and patterns.

Print the current environment variables — every `NAME=value` pair exported into the running process, plus the gateway for running a command with a modified environment.

Parse and execute a string as if it were a shell command.

Replace the current shell with another program.

Terminate the current shell or script with an optional exit status.

Automate interactive command-line programs — Tcl-based scripting tool that "expects" patterns in a program's output and "sends" responses, like a programmable user.

Set an environment variable and mark it for export to child processes.

Evaluate an expression (POSIX arithmetic / string ops).

Edit and re-run the previous command in $EDITOR.

PowerShell's pipeline-loop cmdlet — the xargs / while-read equivalent for running a block per object.

Define a reusable named function in a shell script.

PowerShell's current-time and date-arithmetic cmdlet.

PowerShell's documentation cmdlet — the man / info equivalent that pulls help text for cmdlets, functions, and conceptual topics.

PowerShell object introspection — list properties, methods, and events on an object.

Parse short option flags inside a shell script.

OpenPGP encryption, signing, and key management — GnuPG.

List the groups a user belongs to — controlling which files, devices, and capabilities the user can access via group permissions.

Show previously run commands from the shell history.

Print the current user's UID, GID, and group memberships.

PowerShell's runtime string-evaluator cmdlet — the `eval` equivalent that parses and executes a string as code. Powerful and dangerous.

Bash/zsh arithmetic-evaluation builtin — assign integer expressions to variables.

Display the manual page for a command — the canonical authoritative documentation that ships with the binary, before tutorials or Stack Overflow answers.

Change a user account password — set, expire, lock, or unlock.

Install, upgrade, and remove Python packages from PyPI — Python's standard package manager, identical CLI across Linux, macOS, and Windows.

Print the value of a specific environment variable (or all of them) — `env` without the subprocess-launching machinery, optimised for scripts that just want to read.

Print formatted text using C-style format specifiers like %s and %d.

Read a line of input into one or more shell variables interactively.

PowerShell interactive prompt — read a string (or SecureString) from the user.

Exit a shell function with a numeric status code.

Install, query, verify, and uninstall individual `.rpm` package files on RHEL / CentOS / Fedora / SUSE — the low-level package backend underneath yum/dnf/zypper.

Toggle shell options like errexit/xtrace and set positional parameters.

Pause execution for a number of seconds.

Load a script into the current shell so its definitions persist.

Evaluate a conditional — file tests, string and number comparisons.

Measure how long a command takes to run.

Show accumulated CPU time used by the shell and its children.

Terminal multiplexer — keep multiple shell sessions alive in one terminal, detach and reattach across SSH disconnects, and split panes for side-by-side work.

Run a handler when the shell receives a signal or exits.

Declare a variable or set its attributes (zsh canonical name).

Read or set the shell process's resource limits (open files, stack, memory, …).

Remove an alias previously defined with alias.

Remove a shell variable or function from the current environment.

Pause until background jobs or processes finish.

Show who is currently logged in — listing each active session with username, terminal, login time, and remote host.

Print the effective username of the current process — the identity files would be created as and that permissions checks resolve against.

Install, upgrade, and remove packages on RHEL / CentOS / Fedora / Amazon Linux via YUM (Yellowdog Updater, Modified) — the RPM-family package manager, succeeded by `dnf` in RHEL 8+.

Change the current working directory.

List the directory stack built up by pushd and popd.

PowerShell's popd — return to the directory most recently pushed.

Pop the top directory off the directory stack and cd into it.

PowerShell's pushd — save the current directory on a stack, then cd.

Push the current directory onto a stack and cd into a new one.

Print the current working directory.

Resume a stopped (Ctrl+Z’d) job and run it in the background.

Schedule recurring commands on Unix — the user's `crontab` file lists `<minute> <hour> <day> <month> <weekday> <command>` entries that cron runs in the background.

Remove a background job from the shell's job table so it survives shell exit.

Print the kernel ring buffer — boot-time hardware probes, device hot-plug events, OOM killer activity, and other kernel-level diagnostics that don't go to userspace logs.

Bring a background or stopped job to the foreground.

Display the system's used and free memory — total RAM, used, free, shared, buffer/cache, and swap, for quick "is this box memory-pressured" checks.

PowerShell's process-listing cmdlet — the ps equivalent.

PowerShell's service-listing cmdlet — like systemctl or service.

List background and stopped jobs in the current shell session.

Query the systemd journal — the central binary log database on systemd-based Linux systems where boot logs, service stdout/stderr, and kernel ring buffer all live.

Send a signal to a process (typically to terminate it).

List open files — including regular files, sockets, pipes, devices, and the processes holding them.

Launch a process with an adjusted scheduling priority (niceness).

Run a command immune to SIGHUP so it survives the terminal closing.

Find PIDs (and optionally command lines) of running processes by name or other attribute — the lookup half of pkill/pgrep.

Return the PID(s) of a running process by exact name — the simpler, Linux-only cousin of pgrep.

Kill processes by name (or other attribute) without first looking up the PID.

List a snapshot of currently running processes.

Change the scheduling priority of an already-running process.

Detachable terminal multiplexer — sessions survive disconnects.

PowerShell's process-launcher cmdlet — the equivalent of background `&` / `nohup` / `Start` for spawning detached or elevated processes.

PowerShell's stop-service cmdlet — like systemctl stop.

Trace system calls and signals received by a running process — Linux's ptrace-based syscall debugger. The canonical "why did my program fail with no useful error" tool.

Control systemd services — start, stop, enable at boot, and inspect status — on every modern Linux distro.

Interactive process viewer — show running processes sorted by CPU or memory, refreshed in place.

Print kernel and OS identification — what kernel version, machine architecture, and OS family the script is running on, for portability branching.

Transfer data from or to a server over HTTP, HTTPS, FTP, and many other protocols.

Query DNS records (A, AAAA, MX, TXT) with richer output than nslookup.

Transfer files over FTP — legacy plaintext protocol; prefer SFTP today.

Simple DNS lookup with one-line output, simpler than dig.

The legacy network interface configurator — still primary on macOS/BSD, deprecated on most Linux distros but still installed.

PowerShell's REST and JSON HTTP client — curl that auto-deserialises the response.

PowerShell's HTTP cmdlet — the curl / wget equivalent.

The modern Linux network utility (from `iproute2`) — manages addresses, links, routes, neighbours, tunnels, and namespaces.

Netcat — read/write arbitrary TCP and UDP data. Used for port probes, one-shot listeners, file transfer, and quick socket debugging.

Show network connections, listening ports, routing tables, and interface statistics.

Query DNS records (A, AAAA, MX, TXT, etc.) for a hostname.

Send ICMP echo requests to test reachability and round-trip latency.

Remote login — DEPRECATED unencrypted predecessor to ssh.

Display and manipulate the IP routing table — the rules that decide which interface and gateway each outbound packet uses.

Remote shell — DEPRECATED unencrypted predecessor to ssh.

Efficient file and directory sync, transferring only changed parts.

Securely copy files between hosts over SSH.

Interactive file transfer over SSH — the secure replacement for FTP.

Socket statistics — the modern Linux replacement for `netstat`, querying kernel sockets directly via netlink.

Open a secure shell on a remote host or run a remote command.

Generate, inspect, and manage SSH key pairs — the asymmetric credentials used by SSH for passwordless authentication and host verification.

Open a plaintext TCP session — legacy terminal + port-probe tool.

PowerShell's reachability-check cmdlet — the ping equivalent that returns structured objects and supports TCP port tests since pwsh 7.

Trace the network path to a destination — listing each hop and its round-trip time, without root privileges.

Print the route packets take to a network host — hop-by-hop, with per-hop round-trip times — by sending probes with incrementing TTL values.

Non-interactive network downloader for HTTP, HTTPS, and FTP.

Look up domain registration / WHOIS records.

Create, extract, and inspect 7-Zip archives (.7z, .zip, .tar.gz, and 30+ other formats) with strong LZMA2 compression and AES-256 encryption.

Compress / decompress single files using the bzip2 (BWT + Huffman) algorithm — better ratio than gzip, slower, single-threaded.

Compress (or decompress) a single file in place using the DEFLATE algorithm.

Bundle and unbundle files into a single archive (often combined with gzip / bzip2 / xz).

Extract files from a ZIP archive — the read side of `zip`, available on every Unix and (since Windows 10 1803) via the bundled bsdtar.

Compress / decompress files using the LZMA2 algorithm — best ratio of any mainstream compressor, slow at compress, fast at decompress, multi-threaded by default.

Package and compress files into a ZIP archive.

Change the group ownership of a file or directory on Unix systems.

Change file mode bits (read / write / execute permissions) on Unix files.

Change the owner (and optionally the group) of a file or directory.

Display the POSIX.1e ACL of a file or directory — the per-user / per-group grants beyond the basic owner/group/other mode bits.

Set or modify the POSIX.1e ACL of a file or directory — grant per-user / per-group access beyond the basic owner/group/other mode bits.

Switch to another user's identity in the current terminal — usually for becoming root or testing as a specific user.

Execute a command with another user's privileges — usually root — without logging out and back in.

Set or display the default permission MASK for newly-created files and directories.

Modify an existing user account — change username, home directory, shell, primary group, supplementary groups, lock / unlock the account, or set the expiration date.