Dragging an app to the Trash removes the app. It does not remove the preferences, caches, logs, and support files the app left in your Library folders, which is why people go looking for a more thorough method. The advice they find is often a list of folders to delete — and some of those folders hold documents rather than settings. This page covers the order that gets an app fully removed without that risk: check for a real uninstaller first, use a tool that shows you a list before it deletes anything, and never use a command that skips the Trash.
The basic removal
Quit the app first — removing a running app leaves it able to write its files back on quit, which is the usual reason something “reinstalls itself”. Then:
- Open Applications in the Finder.
- Drag the app to the Trash, or select it and press Command-Delete.
- Enter your password if macOS asks. Some apps install a helper that needs authorisation to remove.
Apps from the App Store can also be removed from Launchpad: click and hold until the icons jiggle, then click the delete button on the app. That route is exactly equivalent, not more thorough.
For many apps this is genuinely enough. What stays behind is typically a preferences file of a few kilobytes and a cache folder that is dead weight but harmless. It becomes worth cleaning up when you are reclaiming real space, when a reinstall keeps picking up broken settings, or when the app installed background components that keep running.
Check for a real uninstaller first
This step gets skipped constantly and it is the one that removes an app correctly, because the developer knows what their installer put where. Anything that installs a network extension, a virtual disk, a kernel component, or a background daemon usually ships one.
Look in three places. First, the app’s own menus — a Help or preferences pane with an uninstall option. Second, the disk image you installed from, which often contains an uninstaller next to the app. Third, inside the app bundle itself, which you can check for the whole Applications folder at once:
ls /Applications/*/Contents/Resources/*[Uu]ninstall* 2>/dev/null
On the machine used for this article that turned up three apps carrying their own uninstall script — all of them networking or hardware tools, which is exactly the category that needs one. If your app is listed, run the developer’s uninstaller and stop there; nothing below will do a better job.
The easy way: an uninstaller app
If there is no developer uninstaller, the practical option for most people is a dedicated tool rather than hand-searching Library folders. AppCleaner is free, has been around for years, and works the way this kind of tool should: you drag an app onto its window, it searches for related files, and it shows you a checklist of what it found. Nothing is removed until you confirm, and what it removes goes to the Trash rather than vanishing.
That checklist is the feature, not the convenience. Read it before clicking Remove. These tools match files by name and bundle identifier, and matching is inexact in both directions — it can miss files an app named differently, and it can propose something that belongs to a different app with a similar name. If a line in the list is not obviously part of the app you are removing, untick it. A leftover preferences file costs you nothing; a wrongly matched data folder costs you the data.
One habit worth keeping regardless of the tool: empty the Trash a day later, not immediately. If something you use stops working, the files are still there to put back.
By hand: get the bundle ID before you delete
Doing it manually is reasonable, as long as you do the steps in the right order. The important one comes first: read the bundle identifier while the app is still installed. Almost every file an app leaves behind is named after it, and once the app is in the Trash you have lost the easiest way to look it up.
$ plutil -extract CFBundleIdentifier raw -o - /Applications/Calculator.app/Contents/Info.plist
com.apple.calculator
Write that string down. You can also go the other way, finding where an app lives from its identifier, which is useful when an app is not in the Applications folder at all:
$ mdfind "kMDItemCFBundleIdentifier == 'com.apple.calculator'"
/System/Applications/Calculator.app
With the identifier in hand, these are the locations that hold app files. Not every app uses all of them, and most use only two or three:
| Location | What lives there |
|---|---|
~/Library/Preferences | Settings, as bundle.id.plist |
~/Library/Caches | Disposable data, often the largest item |
~/Library/Application Support | Settings and sometimes documents |
~/Library/Containers | Everything a sandboxed app owns, including your files |
~/Library/Group Containers | Shared between related apps |
~/Library/Logs | Diagnostic logs |
~/Library/LaunchAgents | Things set to start automatically |
/Library/LaunchDaemons | System-wide background components |
To see hidden folders in the Finder, press Shift-Command-Period; to jump straight to the right place, press Shift-Command-G and type the path.
The folders that hold your data, not settings
This is the part that makes the difference between tidying up and losing something, and it is missing from most instructions on this subject. Two of the locations above routinely contain files you created:
Containers. A sandboxed app keeps its entire world under ~/Library/Containers/<bundle id>, and for many apps that includes the documents you made with it. Apple’s own apps show the pattern plainly — ~/Library/Containers/com.apple.Notes holds your notes, not a preference file. Deleting a container is deleting the app’s documents.
Application Support. Older, non-sandboxed apps use this for the same purpose. Again the system’s own folders make it concrete: ~/Library/Application Support/AddressBook is your contacts. Elsewhere in the Library, ~/Library/Messages and ~/Library/Mail hold conversations and mail. Those are not caches with unfriendly names.
So the rule for manual removal is narrow on purpose:
- Delete only items whose name clearly matches the app you just removed.
- Before removing a container or an Application Support folder, open it and look. If it contains things you would miss, export or copy them first.
- Leave
Group Containersalone unless you are certain no other app you keep uses it — the name says shared. - When unsure, leave it. Stale preferences take up kilobytes and do no harm.
And if the app is one you might reinstall — a password manager, a notes app, a mail client, anything holding a library — the safest sequence is to export your data from inside the app before uninstalling it, while it can still read its own files.
Use trash, never rm -rf
Most command-line instructions for this reach for rm -rf, which deletes immediately, without confirmation, with no way back. On a path you typed slightly wrong, that is unrecoverable.
macOS ships a better tool for exactly this job. trash moves items to the Trash instead of destroying them, so a mistake is a drag away from being undone:
$ trash -v ExampleApp leftover.log
# Moved "…/ExampleApp" to "/Users/osxhub/.Trash/ExampleApp"
# Moved "…/leftover.log" to "/Users/osxhub/.Trash/leftover.log"
The paths above are shortened and the user name redacted; the format is otherwise as printed. -v reports each move, and -s stops on the first error rather than continuing. Worth checking your macOS version before relying on it in a script — man trash records that it first appeared in macOS 15.0, so anything older needs the Finder instead.
Two habits that pair with it. Run ls on a path before you act on it, so you see what is actually there rather than what you assumed. And remove one item at a time rather than passing a wildcard — trash ~/Library/Caches/com.example.* expands to whatever matches, which may be more than you pictured.
Apps that came from an installer package
An app you installed by running a .pkg may have put files well outside the Applications folder. macOS keeps a receipt listing exactly what each package wrote:
pkgutil --pkgs
pkgutil --files <package-id>
--pkgs lists every package identifier known to the system, and --files prints the paths that package installed, relative to its install location. That is the closest thing to a manifest you will get, and it beats guessing.
One thing pkgutil does not do is uninstall, and the flag that sounds like it does is a trap. The man page is unambiguous about --forget: “Discard all receipt data about package-id, but do not touch the installed files.” Running it makes the system forget the package was ever installed while every file stays exactly where it was — the opposite of what someone reaching for it usually wants.
Quick reference
| Step | How |
|---|---|
| Quit the app | Command-Q, and check it is not still in the menu bar |
| Look for a real uninstaller | ls /Applications/*/Contents/Resources/*[Uu]ninstall* |
| Note the bundle ID first | plutil -extract CFBundleIdentifier raw -o - /Applications/App.app/Contents/Info.plist |
| Find where an app lives | mdfind "kMDItemCFBundleIdentifier == 'com.example.app'" |
| List what a .pkg installed | pkgutil --files <package-id> |
| Remove leftovers recoverably | trash <path> — never rm -rf |
| Let a tool do the searching | AppCleaner, and read its checklist before confirming |
The short version: quit the app, look for the developer’s own uninstaller, and if there is none, either let AppCleaner build the list for you or work through the Library folders using the bundle ID as your filter. Whichever route you take, everything goes to the Trash rather than straight to deletion, and anything you cannot confidently attribute stays where it is.

