Arch Linux is the kind of distro that hands you the keys, a wrench, and a polite note that says: “Good luck, have fun.” That’s greatuntil your definition of “fun” does not include an app deciding today is the day to reinvent itself.

Here’s the twist: on a stock Arch install, updates usually don’t happen automatically. Arch typically updates when you run pacman -Syu (or when you run a helper that effectively does the same thing). So “disabling app updates” on Arch is less like stopping a runaway train and more like: finding out which toddler in your house keeps pressing the “Update All” button.

This guide walks you through the practical ways to stop or limit updatesby disabling update checkers, turning off timers, and (when you absolutely must) pinning specific packages. We’ll also talk about the trade-offs, because Arch is a rolling release: freezing updates can work, but it can also turn your system into a very educational science experiment.

What “Disable Updates” Means on Arch (Pick Your Scenario)

Scenario A: “I don’t want anything to update unless I say so.”

• Good news: you’re already mostly therejust don’t run update commands.
• Better news: you can remove/disable GUI update tools and timers that check in the background.

Scenario B: “I only want to stop this one app from updating.”

• Possible with IgnorePkg (pacman), but it’s risky on a rolling distro.
• Safer alternative: use a different package variant (e.g., LTS kernel), snapshots, or containerized apps.

Scenario C: “My Flatpaks/Snaps keep updating behind my back.”

• Flatpak typically updates via a software center or a timer someone set up.
• Snap updates are designed to be automatic, but you can hold/schedule them.

Step 1: Confirm What’s Actually Doing Updates

Before you disable anything, identify what’s running. Most “mystery updates” come from one of these: PackageKit (GNOME Software / KDE Discover), Flatpak update timers, AUR helpers, or Snap refreshes.

Check systemd timers (the usual culprit)

Look for anything that smells like updates: words like update, flatpak, pamac, packagekit, reflector, or custom timers you forgot you created at 2 a.m.

Check for user-level timers too

Step 2: Disable GUI “App Store” Auto-Checks (GNOME Software / KDE Discover)

If you’re on a desktop environment, you may have a software center that checks for updates and nags you like a well-meaning aunt. On Arch, the big one to watch is PackageKit, because it can conflict with how Arch expects you to upgrade (i.e., attentively).

Option 2.1: GNOME Software turn off update checking (and the nagging)

1. Open GNOME Software → settings/preferences.
2. Disable Automatic Updates (wording may vary).

If you still get update notifications, you can disable GNOME Software’s update behavior via settings keys. (Yes, this feels like adjusting a secret thermostat behind a painting. Welcome to Linux.)

If you don’t use GNOME Software at all, you can remove it. The minimalist approach: uninstall the tool that’s nagging you.

Option 2.2: KDE Discover stop update notifications / background checks

KDE Discover often relies on PackageKit for update integration. If you want Discover for browsing but not for updates, you can either disable its notifications or remove the PackageKit backend.

• Disable notifications: System Settings → Notifications → find Discover/software update notifications and turn them off.
• Remove PackageKit backend (stronger): remove PackageKit packages so Discover can’t manage system updates.

Note: removing PackageKit may affect “software center” functionality, but that’s the pointyou’re taking away the megaphone.

Step 3: Disable Package Updates (pacman) Carefully, Like You’re Defusing Glitter

If your goal is “don’t update anything,” then the simplest answer is: don’t run pacman -Syu. But if you want to prevent specific packages from updating while still upgrading the rest, pacman supports that.

Use IgnorePkg / IgnoreGroup in pacman.conf

Open pacman’s config:

In the [options] section, add (or edit) an IgnorePkg line:

You can also ignore an entire group with IgnoreGroup. pacman supports shell-style glob patterns in these options, which is both powerful and a little terrifyinglike giving a chainsaw to a poet.

Reality check: “Partial upgrades” are a known Arch foot-gun

Arch is a rolling release. That means packages move together, and selectively skipping updates can cause version mismatches (especially with libraries). Sometimes it’s fine for a short time; sometimes it breaks in a way that makes you question your hobbies.

If you must pin something, pick targets that are less likely to cascade breakage (for example, a single GUI app), and avoid pinning core libraries like glibc, icu, openssl, Mesa, systemd, or your kernel stack unless you truly know what you’re doing.

Safer alternative: use an LTS kernel instead of freezing kernel updates

If your pain is “new kernel broke my Wi-Fi/graphics,” consider switching to the LTS kernel package rather than ignoring kernels entirely. That keeps you on a supported track without turning upgrades into a Jenga tower.

Step 4: Stop AUR “App” Updates (yay/paru) Without Nuking Your Workflow

If you use AUR helpers like yay or paru, your “app updates” might be coming from the AUR side. Two key ideas:

• pacman updates official repo packages.
• AUR helpers rebuild packages from PKGBUILDs and can update them when you run the helper’s upgrade command.

Easy mode: don’t run AUR upgrades automatically

Many people alias an “upgrade everything” command that includes AUR updates. If you want fewer surprises, separate your workflows:

Pinning an AUR package

For packages installed as pacman packages (including ones built from AUR), ignoring them in /etc/pacman.conf can prevent upgrades. Some helpers also respect pacman ignore rules during full upgrades, but behavior can vary by tool and configuration.

Practical tip: if you’re pinning because “latest version is broken,” consider keeping a known-good package file in your cache and documenting the downgrade steps, rather than pretending the future won’t arrive.

Step 5: Disable Flatpak Updates (If Flatpak Is Your “Apps” Layer)

Flatpak updates usually happen when: (1) you run flatpak update, (2) GNOME Software / Discover updates Flatpaks, or (3) you (or your distro tooling) created a systemd timer to do it automatically.

Find and disable Flatpak update timers

If you find one, disable it:

Disable Flatpak updates by removing the updater (software center path)

If GNOME Software or Discover is doing the Flatpak updates, disabling those tools (or their update settings) typically stops Flatpak updates too.

Manual control: check updates without installing

Want visibility without surprise updates? List what would update:

Then update only when you’re ready:

Step 6: Disable Snap Updates (Only If You Use snapd on Arch)

Snap is less common on Arch than pacman/AUR/Flatpak, but if you installed snapd, snaps are designed to refresh automatically. You generally can’t “turn it off forever” in the same way you can ignore pacman packages, but you can hold updates or schedule them to specific windows.

Hold snap updates (pause auto-refresh)

Or hold a specific snap:

Schedule snap refreshes (so updates happen when you choose)

This approach is especially useful if your real problem is “snap updates happen while I’m working,” not “updates must never happen.”

Recommended Strategy: “Disable Automatic Updates” Without Breaking Arch

If you want the best balance between control and stability, here’s a sensible playbook:

1) Remove or tame GUI update managers

• If you don’t use them, uninstall GNOME Software / Discover and PackageKit backends.
• If you do use them, disable auto-checking and notifications.

2) Audit and disable systemd timers

• Disable any update timers you didn’t explicitly decide you want.
• Keep a short list of what you disabled and why (future-you will thank you).

3) Avoid long-term pinning of core libraries

• Use IgnorePkg only as a temporary bandage.
• If a core component is the issue, prefer alternatives like LTS kernels, snapshots, or containers.

4) Update on your schedule (but actually schedule it)

Disabling auto-updates is fine. Disabling updates forever is how browsers turn into fossil exhibits. Pick a cadence: weekly, biweeklywhatever matches your risk tolerance.

FAQ

“Can I completely disable updates in pacman?”

pacman doesn’t run in the background by default. So “disabling updates” usually means “stop using tools that run pacman/package actions automatically.” If you mean “prevent any package changes,” that’s more like filesystem immutability or read-only snapshotseffective, but a different level of commitment.

“Is it safe to ignore a package update on Arch?”

Sometimes, briefly. But Arch expects full upgrades, and selective skipping can lead to dependency mismatches. If you pin, do it intentionally, document it, and revisit it soon.

“Why do I see update notifications right after I updated?”

Often a mismatch between a software center’s update metadata (PackageKit/appstream) and your actual pacman state. Disabling/removing the notifier (or PackageKit integration) is usually the cleanest fix.

Field Notes: Real-World “No Updates” Experiences on Arch (Extra)

Let’s talk about what people typically experience when they try to “disable app updates” on Archbecause the theory is neat, but the reality is where the comedy (and occasional tragedy) lives.

Experience #1: “I disabled updates… but nothing changed.”
This is extremely common, and it’s usually because Arch wasn’t auto-updating in the first place. What changed was the notifications: GNOME Software or KDE Discover started reminding you that updates exist, even though you were already updating via pacman -Syu. The fix isn’t “stop pacman,” it’s “stop the messenger.” Disabling GNOME Software’s update behavior or removing PackageKit often makes the desktop stop nagging.

Experience #2: “I pinned one package and my system slowly turned into soup.”
The first week is fine. The second week is fine. Then one day you upgrade and a dependent library jumps versions, while your pinned app still expects the older one. Suddenly you’re staring at a cryptic error message that looks like it was generated by a haunted typewriter. This is why Arch documentation and community advice consistently warns against partial upgrades: on a rolling release, packages are meant to move together. If you must pin, the most successful stories are short-term pins with a clear exit plan (wait for a bugfix release, switch to a different build, or migrate the app to Flatpak).

Experience #3: “Flatpak is updating at 6:30 AM and I am not a morning person.”
When Flatpaks update “by themselves,” it’s almost always because something else is driving it: a software center, or a systemd timer someone set up to be helpful. The easiest win is auditing timers (systemctl list-timers and systemctl --user list-timers) and disabling anything Flatpak-related. People who remove the timer often report that Flatpak “mysteriously stopped auto-updating,” which is exactly what we were aiming for.

Experience #4: “I hate updates, but I hate insecure browsers more.”
Many users eventually land on a compromise: they disable automatic checks and background updates, but keep a regular manual update day. It’s the Linux equivalent of meal prep. You don’t want to cook every day, but you also don’t want to eat mystery leftovers from 2019. A weekly cadence (and updating right before you start a work session, not during it) tends to reduce the pain dramatically.

Experience #5: “The real fix was switching package formats.”
If a particular desktop app is the chronic troublemaker (UI changes, regressions, plugin breakage), many people get better results by switching how they install it. For example:

• Use Flatpak for the app, so it’s isolated from fast-moving system libraries.
• Or use the repo/AUR version but keep a downgrade path and pause updates briefly when needed.

The punchline is that “disabling updates” is rarely the end goal. The end goal is control: fewer interruptions, fewer regressions, and fewer surprise changes. On Arch, the most stable route is usually: disable background updaters, keep system upgrades intentional, and treat package pinning like a temporary splintnot a lifestyle.

Conclusion

To disable app updates on Arch Linux, you usually don’t need to fight pacmanyou need to disable the background tools that check for updates, silence software center notifications, and remove timers that run updates automatically. If you also need to pin specific packages, use IgnorePkg sparingly and with caution, because Arch expects full upgrades.

SEO tags (JSON)

The post How to Disable App Updates on Arch Linux appeared first on Global Travel Notes.