Windows PowerShell to Linux Terminal: Your Survival Guide! 🚀

So you’ve booted in to Fedora 43, all excited and found a juicy online tutorial!! And its asking you to launch the terminal to do something - You did. But before you blindly follow these commands you really want to know what they do.

Don’t panic—this is your moment. Remember how you used to tweak the Windows Registry with esoteric hexadecimal values and pray nothing broke? Welcome to the Linux alternative: commands that are somehow more transparent and less scary.

This post documents every Linux tool/command we’ve used so far in our Fedora journey. Think of it as your personal cheat sheet. Well — Maybe don’t tattoo your favorite on your arm… but you could. 😄

Each command includes:

• A TL;DR (what it actually does)
• A bit of Windows context for fellow refugees
• A link to the man page or official docs

Tested with: Fedora 44 · dnf5 5.4.6.0 · fish 4.6.0 · bash 5.3.9

📋 Quick Reference Table

🔍 System Information & Monitoring

lsblk — List Block Devices

TL;DR: Shows all your storage devices (hard drives, SSDs, USB sticks) in a tree format so you know what you’re about to partition.

On Windows, you’d click through Disk Management and hope you didn’t format the wrong drive. On Linux, you run:

lsblk
lsblk -f # include filesystem info

It lists all block devices and their mount points. Crucial when you’re installing, nuking Windows, or just trying to remember which disk is which.

• Man page: https://man7.org/linux/man-pages/man8/lsblk.8.html

systemctl — Systemd Service Controller

TL;DR: Start, stop, enable, or disable services. Think services.msc, but actually powerful and scriptable.

Some handy examples:

sudo systemctl status service-name
sudo systemctl start service-name
sudo systemctl enable service-name
sudo systemctl restart service-name

We used this to:

• Enable and manage dnf-automatic timers

• Start/enable things that should run at boot

• Check whether background services are happy or throwing a tantrum

• Man page: https://man7.org/linux/man-pages/man1/systemctl.1.html

btop — Better top (Fancy Resource Monitor)

TL;DR: A gorgeous, modern system monitor with graphs, colors, and all the stats your inner nerd craves.

Install it on Fedora:

sudo dnf install btop
btop

You get:

• Live CPU, RAM, disk, and network graphs
• Per-process stats
• Mouse support
• Themes, because of course

It’s like Task Manager, if Task Manager had a glow-up and discovered Linux.

• Help: press h inside btop

htop — Interactive Process Viewer

TL;DR: A lightweight, colorful replacement for top. More minimal than btop, but still much friendlier than the old-school top.

Install and run:

sudo dnf install htop
htop

You can:

• Sort processes by CPU, memory, etc.
• Kill processes without reaching for kill -9
• Quickly see which app is chewing your CPU

Think of htop as the ThinkPad of system monitors: not flashy, but rock solid.

• Man page: https://man7.org/linux/man-pages/man1/htop.1.html

lm_sensors + sensors — Hardware Temperature Monitoring

TL;DR: Lets you see CPU, GPU, and motherboard temps, plus voltages and fan speeds.

On Windows, you’d install something like HWMonitor or some sketchy motherboard vendor tool. On Fedora:

sudo dnf install lm_sensors
sudo sensors-detect
sensors

Now you can see if your poor old laptop (in my case, a Core i7-7700HQ) is about to become a space heater.

• ArchWiki (gold): https://wiki.archlinux.org/title/Lm_sensors

journalctl — Every Boot, Logged

TL;DR: Ask the system exactly what it did, and when — right down to the second.

journalctl --list-boots

IDX  BOOT ID                          FIRST ENTRY                  LAST ENTRY
-152 7ec49501831f4b87a919da20803f8c39 Tue 2026-05-05 16:41:31 AEST Tue 2026-05-05 21:19:14 AEST
-151 c33f238cb59945b0be8e9980c03e402c Tue 2026-05-05 21:19:27 AEST Tue 2026-05-05 21:31:13 AEST
-150 fe29c4397d9e46d8bc9683af2f2407e8 Tue 2026-05-05 21:31:27 AEST Tue 2026-05-05 22:12:05 AEST

Three boots in one evening? The middle one is a system-upgrade session — it boots, replaces every package, and shuts down without ever reaching a login prompt. On Windows you’d watch a percentage and a spinner; here the whole thing is sitting in a log afterwards.

Useful variations:

journalctl -b -151                              # one specific boot
journalctl --since "2026-05-05" --until "2026-05-06"

• Full timeline: Fedora 43 → 44 in eleven minutes

rpm -q — What’s Actually Installed

TL;DR: Query the package database directly, bypassing any package manager’s opinion of what’s going on.

rpm -q kernel
rpm -q kernel | grep -c fc43    # 0 -> the old release is really gone

kernel-7.2.4-200.fc44.x86_64
kernel-7.2.7-200.fc44.x86_64
kernel-7.2.8-200.fc44.x86_64

After a release upgrade this is the honest check: are any old-release kernels still sitting in /boot eating space? rpm answers from the database, not from whatever the boot menu happens to be showing you.

• Man page: https://man7.org/linux/man-pages/man8/rpm.8.html

📦 Package Management (Fedora’s Superpower)

dnf — Dandified YUM (Fedora’s Package Manager)

TL;DR: Install, update, remove, and search for software. Your apt / App Store / “download random EXE off the internet” replacement.

Common patterns:

sudo dnf install package-name
sudo dnf remove package-name
sudo dnf search keyword
sudo dnf list --installed

No adware installers, no random browser toolbars mysteriously appearing, no “Next → Next → I swear I unchecked that…” drama.

• Docs: https://docs.fedoraproject.org/en-US/quick-docs/dnf/

dnf upgrade — Update Everything

TL;DR: Updates all installed packages to their latest versions.

sudo dnf upgrade

That’s it. No “cumulative update” KB numbers. No “this update failed, rolling back…” while you stare at a spinning circle.

• Docs: Covered in DNF docs: https://docs.fedoraproject.org/en-US/quick-docs/dnf/

dnf-automatic — Automatic Updates (The Lazy Admin Mode)

TL;DR: Automatically checks for and installs updates on a schedule using systemd timers.

Install and enable:

sudo dnf install dnf5-plugin-automatic

Enable automatic install timer:

sudo systemctl enable --now dnf5-automatic.timer

You can tune behavior in:

sudo nano /etc/dnf/automatic.conf

You choose whether it should:

• Just notify you

• Download only

• Download and install automatically

• Man page: man dnf5-automatic — the timer and the config both come from dnf5-plugin-automatic

max_parallel_downloads=10 — Making DNF Faster

TL;DR: Tells DNF to download up to 10 packages at once instead of the default 3.

Edit the DNF config:

sudo nano /etc/dnf/dnf.conf

In the [main] section add:

max_parallel_downloads=10

Now your updates actually use your internet connection instead of politely settling for three at a time.

dnf system-upgrade — Upgrading The Whole Release

TL;DR: Move from one Fedora release to the next without reinstalling.

# 1. Download the new release — running system untouched
sudo dnf system-upgrade download --releasever=44 --best

# 2. Reboot into the upgrade environment and apply it
sudo dnf5 offline reboot

Step 1 is completely reversible — it stages a stored offline transaction and installs nothing, and dnf system-upgrade clean clears it. Nothing on the system changes until you run step 2. That’s the safety valve Windows Update never gave you.

The actual work happens in a throwaway boot environment, because a major-version jump replaces nearly everything at once and you don’t want half-updated services running while it happens. So you go through three boots: your normal session ends, the upgrade environment runs the transaction, and the new release boots.

Mine took 11 minutes 21 seconds across 4,646 packages.

• Full timeline: Fedora 43 → 44 in eleven minutes

⚙️ File Permissions & Archives

chmod +x — Make a File Executable

TL;DR: “Let this file run as a program.” Without this, your script is just a text file.

Usage:

chmod +x script.sh
./script.sh

On Windows, anything ending in .exe or .bat just runs (sometimes to your regret). On Linux, execution is a permission you grant consciously. More friction, more security.

• Man page: https://man7.org/linux/man-pages/man1/chmod.1p.html

unzip — Extract ZIP Files

TL;DR: Command-line Extract All… for .zip archives.

Basic usage:

unzip file.zip # Extract here
unzip file.zip -d dest/ # Extract to dest/
unzip -l file.zip # List contents

That’s it. No wizard, no “Please upgrade to Pro to extract this file” nonsense.

• Man page: https://manpages.ubuntu.com/manpages/jammy/man1/unzip.1.html

🔒 Privileged Operations

sudo — Superuser Do

TL;DR: Run one command as the superuser (root). Like right-click → “Run as administrator”, but you type it.

Examples:

sudo dnf install package-name
sudo nano /etc/some-config.conf
sudo reboot

Linux assumes you’re a responsible adult and doesn’t run everything as root all day. sudo is you explicitly saying, “Yes, this change is serious and I mean it.”

• Man page: https://man7.org/linux/man-pages/man8/sudo.8.html

🌐 Downloading & Networking

wget — Web Get

TL;DR: Simple command-line downloader. Great for “here’s a URL, just grab the file.”

Examples:

wget https://example.com/file.zip
wget -c https://example.com/big.iso # resume

If all you want is to download a file and move on with your life, wget is your friend.

• Man page: https://man7.org/linux/man-pages/man1/wget.1.html

curl — Client URL

TL;DR: The Swiss Army knife of web requests. Downloads files and talks to APIs, inspects headers, and more.

Examples:

curl https://example.com/file.zip -O
curl -I https://example.com # just headers
curl -X POST -d "foo=bar" https://api.example.com/endpoint

If wget is “download file, done”, curl is “perform HTTP kung-fu and maybe debug an API along the way.”

• Man page: https://man7.org/linux/man-pages/man1/curl.1.html

🔧 System Maintenance

fwupdmgr — Firmware Update Manager

TL;DR: Updates firmware (BIOS, SSD firmware, etc.) from within your running system. No USB boot tools, no weird vendor utilities.

Typical flow:

sudo fwupdmgr refresh # refresh metadata
sudo fwupdmgr get-devices # list supported hardware
sudo fwupdmgr get-updates # see available updates
sudo fwupdmgr update # apply updates

This talks to LVFS (Linux Vendor Firmware Service), where vendors publish signed firmware. It’s the least painful firmware update experience you’ll ever have.

• Man page: https://manpages.ubuntu.com/manpages/jammy/man1/fwupdmgr.1.html

🛠️ Development & Version Control

git — Version Control for Everything

TL;DR: Track changes to files over time and sync them to remote repositories. Originally for code, now used for everything.

Typical usage:

git init
git clone https://github.com/owner/repo.git
git status
git add .
git commit -m "My message"
git push
git pull

Even if you’re not a full-time dev, git is brilliant for:

• Dotfiles

• Config backups

• Personal scripts

• Docs: https://git-scm.com/doc

🎨 Desktop Customization

gnome-tweaks — GNOME Tweaks

TL;DR: A GUI tool to customize GNOME beyond the basics. Themes, fonts, behavior, window buttons—it’s all here.

Install:

sudo dnf install gnome-tweaks

Launch:

• From the terminal: gnome-tweaks
• Or search for “Tweaks” in Activities

From here you can:

• Change themes and icons
• Manage GNOME extensions
• Tweak fonts and scaling
• Adjust window and workspace behavior

It’s like finally getting the proper “Advanced Settings” button that Windows kept hiding from you.

• Package info: https://packages.fedoraproject.org/pkgs/gnome-tweaks/gnome-tweaks/

🐟 Shell Aliases & Diagnostics

Everything below came out of two posts about the same uncomfortable idea: your shell is allowed to lie to you, and it will never mention it unprompted.

• The Day My Own Alias Bit Back — find had quietly become fd
• The Ghost In My .bashrc — grep had become ag, which isn’t installed

type -a — Which Definition Wins?

TL;DR: “Show me every definition of this name, in the order the shell will try them.”

type -a find

In fish, that answers:

find is a function with definition
# Defined in ~/.config/fish/functions/find.fish @ line 1
function find --wraps=fd --description 'alias find fd'
    fd $argv
end
find is /usr/bin/find

In bash — which has no such function — the same query is simply:

find is /usr/bin/find

The point is the ordering. A function (or alias) always wins over PATH, so the real binary can be sitting right there and still never get called. When a command behaves strangely, this one line usually explains why.

• Bash manual: https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html

command -v — Does This Command Exist?

TL;DR: Print where a command lives — its path for a real binary, its definition for an alias, function or builtin — or print nothing at all.

command -v rg     # /usr/bin/rg
command -v ag     # (no output, exit code 1)

Worth seeing explicitly, because an alias doesn’t answer with a location — it answers with itself:

command -v grep     # alias grep='rg --color=auto'

Only a real binary gives you a path back.

That silence is the whole diagnosis for a ghost alias: there is nothing there to run.

command earns its keep twice. With -v it verifies; without -v it steps past whatever alias or function is standing in front of the real binary:

command find --version    # find (GNU findutils) 4.10.0

That’s the exit door for when an alias has taken over a command you genuinely need.

• Bash manual: https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html

alias — List Your Shell Remaps

TL;DR: Everything your shell has been told to substitute.

bash -ic 'alias'

Running it inside bash matters — it loads .bashrc and the system-wide /etc/profile.d/ aliases, so you see what is genuinely active rather than what you remember typing:

alias cat='bat'
alias cls='clear'
alias egrep='grep -E --color=auto'
alias fgrep='grep -F --color=auto'
alias fixuserial='sudo fix-usb-serial'
alias grep='ag'
alias man='tldr'
...

Now stare at egrep and fgrep. Neither one points at ag — they point at grep. But bash tests the first word of an alias replacement for further alias expansion, so the chain quietly completes itself:

$ bash -ic 'egrep --version'
bash: ag: command not found...
$ bash -ic 'fgrep --version'
bash: ag: command not found...

One dead alias, three dead commands. And alias egrep='grep -E --color=auto' lives in /etc/profile.d/colorgrep.sh, where it looked completely healthy on its own. A ghost you can see is easy — it’s the ones inheriting the ghost that get you.

To remove an alias: unalias grep.

And the advice, straight from the bash manual:

For almost every purpose, shell functions are preferable to aliases.

Fish took that seriously: my find, ls, cat and grep are all functions, not aliases. Functions handle arguments properly; aliases are text substitution. .bashrc is where the text-substitution ones live — which is exactly why the two bugs I’ve hit both came from there.

• Bash manual: https://www.gnu.org/software/bash/manual/html_node/Aliases.html

bash -ic — Test A Command In Bash

TL;DR: Run one command inside bash, so you’re testing bash and not whatever shell you happen to be sitting in.

bash -ic 'grep --version'
bash -ic 'alias grep'

Both flags are documented in Invoking Bash:

• -i — “Force the shell to run interactively.” — so startup files and aliases actually load
• -c — “Read and execute commands from the first non-option argument command_string, then exit.”

This is the difference between discovering that grep is broken in bash and wrongly assuming it’s broken everywhere. On my machine, fish’s grep works and bash’s doesn’t — and you only find that out by asking each shell separately.

• Bash manual: https://www.gnu.org/software/bash/manual/html_node/Invoking-Bash.html

find — Recursively Search The Filesystem

TL;DR: Walk a directory tree and match on name, type, depth or age. The original — and still the one every script calls.

# Files, depth-limited
find ~ -maxdepth 3 -type f -name '*.log'

# Directories whose name carries an old release — the fossil dig
find ~ -maxdepth 3 -type d \( -iname '*fedora43*' -o -iname '*fedora-43*' \)

~/TuneUPScripts/OMEN-Fedora-43

Two things catch people out constantly.

The \( … \) grouping is not decoration. Written flat, this:

find . -maxdepth 1 -type d -iname '*43*' -o -iname '*44*'

parses as (-type d and -iname '*43*') or (-iname '*44*') — so the type filter silently stops applying to the second pattern and files come back in a directories-only search. I checked that against a two-file fixture rather than trusting the man page: grouped, one directory; ungrouped, the directory plus a .txt. The backslashes are eaten by your shell — find itself only ever sees parentheses.

-iname ignores case; -name doesn’t. Use -iname for release strings — they turn up as F43, f43 and Fedora-43 depending on which day you named them.

Fedora ships GNU findutils. fd is the modern rewrite with flags that don’t match — the whole subject of The Day My Own Alias Bit Back.

• Man page: https://man7.org/linux/man-pages/man1/find.1.html

fd — A Modern Replacement For find

TL;DR: Recursive file searching with sensible defaults and a much shorter syntax.

fd pattern               # search here, recursively
fd -d 3 -t file . eng    # depth 3, files only, under ./eng
fd -e md                 # by extension

⚠️ The path is the second positional argument. fd -d 3 -t file eng treats eng as the pattern and searches your current directory — which is why it can return nothing at all while find returns three files. Give it an explicit . pattern first: fd -d 3 -t file . eng.

Its flags are not interchangeable with find, and that mismatch is the whole subject of The Day My Own Alias Bit Back:

Fedora ships it as sudo dnf install fd-find. By default it skips hidden files and anything .gitignored — add -H (--hidden) and -I (--no-ignore) when you want absolutely everything.

• Project: https://github.com/sharkdp/fd

grep — Search Inside Files

TL;DR: Search inside files. -r walks a directory tree; -l prints only the names of the files that matched.

grep -rl "OMEN-Fedora-43" ~/.config/save-my-windows

/home/bitzy/.config/save-my-windows/layout.json

• -r — recursive, don’t stop at the current directory
• -l — list matching filenames instead of every matching line

That pairing is the one worth memorising. Plain grep -r dumps every matching line, which is what you want when hunting a string — and useless when you want to know which files still reference something you already removed.

It’s the second half of the two-command home-directory audit: find for stale names, grep -rl for stale contents.

⚠️ On this machine grep is remapped in both shells — fish wraps it in a function that ends up at rg, while .bashrc carries alias grep='ag' for a program that was never installed. Which shell you’re in decides whether this command works at all. Full story: The Ghost In My .bashrc.

• Man page: https://man7.org/linux/man-pages/man1/grep.1.html

stat — File Birth Time

TL;DR: A file’s metadata — and with %w, the birth time of the current inode: when this version of it came into being, which is a different question from when it was last modified.

stat -c '%w' ~/TuneUPScripts/OMEN-Fedora-43

2026-04-25 21:29:54.519465576 +1000

Three format specifiers, three different questions:

A file written once and never touched shows %w and %y identical — how you can tell the file that’s there now was written in one go and left alone. A file created in April and edited last night shows both, and the gap between them is the history.

⚠️ %w prints - on filesystems that don’t record birth times. Fedora’s ext4 and btrfs do, which is why it works out of the box here.

This is the command that made Fossil Dig possible. Directory names lie about when you chose them; %w reports the clock of the file that’s actually on disk.

• Man page: https://man7.org/linux/man-pages/man1/stat.1.html

💭 Final Thoughts

If you’ve made it this far, you’ve already made a bigger mental shift than most lifelong Windows users ever do.

The big realization for me was this:

The Windows world hides complexity behind wizards and checkboxes.
The Linux world exposes it with commands and config files—but gives you control in return.

These commands are the foundation of your new life on Fedora. As this blog series expands, this list will grow too. I’ll keep coming back to this post and adding new entries as we explore more tools together.

If there’s a command you’d like me to break down next—or you’ve seen it in a screenshot and thought “err… what does that do?”—drop a comment or ping me. 🐧🔥