Deleting a Mac app is supposed to be simple: drag it to the Trash, empty the Trash, and move on. But macOS often leaves behind preferences, caches, application containers, logs, support files, and other data scattered throughout your user Library.

That can become a problem over time, especially on Macs with limited SSD storage.

PureMac takes a different approach to Mac cleanup. Instead of simply deleting applications, this free and open-source macOS utility searches for the files and folders associated with them and helps you review those leftovers before sending them to the Trash.

The app is built with SwiftUI and uses several signals—including bundle identifiers, developer team identifiers, entitlements, Spotlight metadata, and file paths—to determine which files are likely connected to an application.

It also goes beyond application removal. PureMac can locate orphaned files from applications you deleted months or years ago, clean developer-related data such as Xcode DerivedData and simulator runtimes, and identify caches created by tools such as Docker, npm, Yarn, pnpm, and Homebrew.

Most importantly, PureMac is free, open source, and released under the MIT license, with no telemetry or subscription required.

Here’s everything you need to know about PureMac, including its features, privacy model, installation methods, permissions, security protections, and how it compares with other Mac cleaning utilities.

What Is PureMac?

PureMac is a native Mac cleaning and application-uninstaller utility designed to find unnecessary files without relying on a subscription model.

The project is built with SwiftUI and is open source, allowing anyone to inspect the code, fork the project, or contribute improvements.

Rather than treating every file as disposable “junk,” PureMac separates different types of data and gives users an opportunity to review what will be removed.

Its main functions include:

• Removing applications and associated files
• Finding orphaned application leftovers
• Cleaning user and system caches
• Removing selected logs and temporary files
• Cleaning Xcode development data
• Managing Homebrew caches
• Cleaning npm, Yarn, and pnpm caches
• Finding Docker-related storage
• Identifying large and old files
• Emptying supported Trash locations
• Scheduling optional cleanup operations

The emphasis is on reviewing files before deletion, rather than automatically wiping everything discovered during a scan.

How PureMac Uninstalls Mac Apps

Dragging an application to the Trash does not necessarily remove everything it created.

An application can leave files in locations such as:

~/Library/Application Support
~/Library/Caches
~/Library/Preferences
~/Library/Containers
~/Library/Logs

PureMac attempts to identify these related files using a multi-level matching system.

Its matching process can consider:

• Bundle identifiers
• Developer team identifiers
• Application entitlements
• Spotlight metadata
• Containers
• Company names
• File paths
• Normalized application names
• Application-specific matching rules

This is important because simply searching for the application’s name is not always enough to identify everything it installed.

PureMac provides three matching sensitivity levels—Strict, Enhanced, and Deep—so users can choose how aggressively the application searches for related files.

You can also launch an uninstall scan directly from Finder through:

Services → Uninstall with PureMac

That makes it possible to select an application and immediately inspect its associated files.

PureMac Can Find Leftover Files From Deleted Apps

One of PureMac’s more useful features is its Orphan Finder.

Deleting an application today doesn’t necessarily mean its associated files disappear. A preference file or application container can remain in your Library for years.

PureMac scans ~/Library and compares discovered files against applications that are currently installed.

For example, an old container such as:

~/Library/Containers/com.example.application

could potentially be identified as an orphan if the corresponding application is no longer installed.

This can be particularly useful on Macs that have accumulated years of software installations and removals.

Instead of manually searching through the Library for old application data, PureMac gives you a centralized list to review.

PureMac System Cleaner

PureMac also includes a broader cleaning system for files that aren’t necessarily tied to one particular application.

Its Smart Scan can run multiple cleanup categories in parallel.

System Junk

This category targets system caches, logs, and temporary files that can accumulate during normal macOS operation.

User Cache

PureMac dynamically discovers user cache locations rather than depending entirely on a fixed list of applications.

AI App Data

The cleaner can identify certain data associated with AI applications such as Ollama and LM Studio, including logs and caches.

Some history-related cleanup options are presented separately rather than being automatically removed.

Mail Files

Downloaded mail attachments and related local files can consume considerable storage over time.

PureMac can identify this type of data so users can decide whether it should be removed.

Trash Bins

The application can clean supported Trash locations, including Trash folders associated with external volumes.

Large and Old Files

PureMac can identify files larger than 100 MB and files that have not been modified for more than a year.

These files are not automatically selected for deletion, which is important because an old or large file isn’t necessarily useless.

Xcode Junk

For developers, Xcode can generate substantial amounts of data over time.

PureMac can identify:

• DerivedData
• Xcode Archives
• Simulator caches
• Downloaded simulator runtimes

Simulator runtimes are handled through Apple’s simctl runtime delete mechanism rather than being treated as ordinary files.

Homebrew Cache

PureMac respects a custom HOMEBREW_CACHE location when one is configured.

That makes the cleanup process more useful for developers who don’t use the default Homebrew configuration.

Node.js Caches

The cleaner can identify cache data associated with:

• npm
• Yarn Classic
• pnpm

For developers who frequently install and remove packages, these caches can grow surprisingly large.

Docker Storage

Docker can accumulate images, containers, build caches, and other data.

PureMac provides a graphical way to inspect this storage rather than requiring users to rely exclusively on commands such as:

docker system prune

The advantage is visibility: you can see what is taking up space before deciding what should be removed.

PureMac Does Not Pretend to Clean “Purgeable Space”

One of the more sensible decisions in PureMac is how it handles APFS purgeable space.

The application can display purgeable storage as part of its storage breakdown, but it does not present that space as junk that needs to be manually deleted.

That’s because macOS already manages purgeable storage and can reclaim it when necessary.

Third-party applications cannot reliably force macOS to turn every byte labeled as purgeable into immediately available storage.

PureMac therefore treats the number as information rather than a marketing opportunity.

That’s a welcome difference from Mac cleaning utilities that advertise huge amounts of “reclaimable” space without clearly explaining what that storage actually represents.

Does PureMac Send Your Data Anywhere?

According to the project’s documentation, PureMac does not include telemetry or analytics and does not require a network connection to perform its core functions.

The application does not need to upload scan results to a remote server to identify files.

That matters because a Mac cleaner potentially has access to extremely sensitive parts of a user’s storage.

PureMac’s open-source model also gives technically minded users another way to verify its behavior: the source code is publicly available for inspection.

There is no account requirement, subscription, or cloud-based cleaning service involved.

PureMac Requires Full Disk Access

There is an important catch.

PureMac requests Full Disk Access, one of the broadest privacy permissions available to macOS applications.

The reason is straightforward: macOS protects many directories and databases from ordinary applications.

Without Full Disk Access, a cleaning application may not be able to inspect certain Mail data, protected application containers, Safari data, and other restricted locations.

PureMac’s documentation says that without this permission, a significant portion of its scanning capabilities can be unavailable.

During setup, PureMac guides users through the required permission in System Settings.

If a cleanup operation fails because access has not yet been granted, the application can direct the user back to the relevant settings and retry after the permission is enabled.

Should You Give a Mac Cleaner Full Disk Access?

This is the most important security consideration before installing PureMac—or any similar application.

Full Disk Access is powerful. An application with that permission can potentially access files that ordinary applications cannot.

That’s why the open-source nature of PureMac is significant, but it does not mean users should automatically trust the application without reviewing what it does.

Before using a disk cleaner, make sure you understand:

• What permissions it requests
• Where it sends data
• Whether it uses telemetry
• How it handles deleted files
• Whether removed files can be recovered
• What paths it is allowed to modify

PureMac Sends Deleted Files to the Trash

One of PureMac’s stated design principles is that files it removes are sent to the macOS Trash rather than being permanently unlinked immediately.

This provides an important safety net.

If you discover that you accidentally removed something important, you can potentially restore it from the Trash before permanently emptying it.

However, this should not be treated as a substitute for reviewing files before deletion.

Once the Trash is emptied, recovery becomes considerably more difficult.

Be Careful With Application Leftovers

Not everything inside ~/Library is useless.

A leftover preferences file might contain:

• Application settings
• License information
• Saved configurations
• Local databases
• User preferences
• Other application-specific data

Removing a cache is generally less concerning because applications can often regenerate it.

Removing a preference file, database, container, or other application data is different.

For that reason, users should always inspect the full file path and filename before approving a cleanup operation.

PureMac’s approach of requiring explicit confirmation is therefore important.

Scheduled Cleaning

PureMac also offers optional scheduled cleaning.

Users can configure intervals ranging from hourly to monthly and establish thresholds that determine when an automatic background cleanup should take place.

This can be useful for people who regularly generate large amounts of temporary data.

However, scheduled deletion deserves extra caution because automatic cleanup reduces the amount of time you have to inspect individual files.

For important Macs, a conservative manual-cleaning approach is generally preferable.

PureMac vs. CleanMyMac, Pearcleaner, Mole, and OnyX

PureMac isn’t the only Mac maintenance utility available.

Here’s how it compares conceptually with several popular alternatives:

The exact feature sets and licensing terms of these projects can change, so users should check each project’s current documentation before making a decision.

The biggest advantage PureMac has for technically minded Mac users is its combination of a native graphical interface, open-source code, and no subscription requirement.

PureMac vs. AppCleaner

AppCleaner has long been popular among Mac users who want a simple way to uninstall applications and remove associated files.

PureMac takes a broader approach.

Instead of focusing primarily on application removal, it combines app uninstalling with orphan detection, system cleanup, developer caches, Docker data, Node.js caches, and other storage categories.

If all you need is a lightweight application uninstaller, AppCleaner may be enough.

If you want a broader storage-cleaning dashboard, PureMac offers considerably more functionality.

PureMac vs. Pearcleaner

Pearcleaner is another open-source Mac application cleaner with a strong privacy-oriented reputation.

The main difference is that PureMac positions itself as a broader system-cleaning utility rather than solely an application uninstaller.

PureMac also uses the MIT license, which is notably permissive and allows commercial use and redistribution under the license terms.

Always check the current licensing files of both projects before redistributing or incorporating code.

PureMac vs. Mole

Mole is particularly appealing to Mac users who are comfortable working in Terminal.

It provides command-line tools for cleaning and maintaining macOS, making it powerful for developers and advanced users.

PureMac’s main advantage is accessibility: its graphical interface makes it easier to inspect categories, review files, and make decisions without memorizing Terminal commands.

For power users, the two approaches can even complement one another.

PureMac vs. CleanMyMac

CleanMyMac is a commercial, polished Mac maintenance suite with a much broader consumer-focused interface.

Its advantage is convenience and the number of features bundled into one commercial product.

PureMac takes the opposite approach: it is free, open source, and focused on transparency rather than premium packaging.

If you want a polished commercial suite and don’t mind paying for it, CleanMyMac remains a major option.

If your priorities are open source, privacy, no subscription, and transparency, PureMac is much more aligned with those goals.

How to Install PureMac

There are several ways to install PureMac.

Install PureMac With Homebrew

If Homebrew is already installed on your Mac, the simplest option is:

brew install --cask puremac

Homebrew handles the application installation for you.

Download the PureMac DMG

You can also download the signed and notarized .dmg release from the project’s GitHub Releases page and move the application into your /Applications folder.

PureMac GitHub Releases

Build PureMac From Source

Developers can compile PureMac themselves.

First install XcodeGen:

brew install xcodegen

Then clone the repository:

git clone https://github.com/momenbasel/PureMac.git
cd PureMac
xcodegen generate

Build the application:

xcodebuild -project PureMac.xcodeproj -scheme PureMac -configuration Release \
  -derivedDataPath build build

Then launch the compiled application:

open build/Build/Products/Release/PureMac.app

The source code is available on the project’s GitHub repository, allowing developers to inspect the scanning and cleaning logic directly.

PureMac on GitHub

PureMac Architecture

The project is organized into several major components:

PureMac/
  Logic/Scanning/     - Scan engine, locations, conditions
  Logic/Utilities/    - Structured logging
  Models/             - Data models and typed errors
  Services/           - Cleaning, scanning, permissions, scheduling
  ViewModels/         - Centralized application state
  Views/              - SwiftUI interface
    Apps/             - Application uninstaller
    Components/       - Shared UI components
    Orphans/          - Orphan finder
    Settings/         - Application settings

Several components are particularly important.

AppPathFinder

The AppPathFinder component handles the application’s heuristic matching system and attempts to determine which files belong to an installed application.

Locations

PureMac maintains a database of macOS locations that can be scanned for application and system data.

Conditions

Application-specific rules help handle unusual cases involving software such as Xcode, Chrome, and Visual Studio Code.

PermissionCoordinator

This component manages Full Disk Access state and coordinates permission prompts and retries.

FullDiskAccessManager

The manager checks whether the required permission is available and helps macOS recognize the application for protected-data access.

CleaningEngine

The cleaning engine is responsible for validating paths and carrying out cleanup operations while applying the project’s safety restrictions.

PureMac Security Features

Because disk cleaners can perform destructive operations, security is more important than simply having a long list of cleanup categories.

PureMac documents several protections designed to reduce the risk of deleting the wrong files.

Symlink protection

Paths are resolved before validation and checked again immediately before deletion to reduce the risk of symlink-based attacks.

Allow-listed paths

PureMac only permits cleaning operations within explicitly approved locations.

A path outside the permitted roots is rejected rather than blindly deleted.

Restricted administrator access

Operations requiring administrator privileges use a narrower allow-list than ordinary user-level cleanup.

System application protection

Apple system applications are excluded from the uninstall workflow.

Explicit deletion confirmation

Destructive operations require confirmation by default.

There is also an option to disable that confirmation, although it is not enabled by default.

These protections don’t make a disk cleaner risk-free, but they demonstrate why the application’s implementation matters just as much as its feature list.

PureMac Troubleshooting: Stale App Icons

After installing or upgrading PureMac through Homebrew, macOS can sometimes display an outdated application icon in Launchpad or the Dock.

This is generally related to macOS LaunchServices and icon caching rather than the application itself.

PureMac’s Homebrew installation process can refresh the LaunchServices registration, but if the old icon remains, users can rebuild the relevant caches manually.

For advanced users, the following commands can refresh LaunchServices and restart the Dock and Finder:

sudo rm -rfv /Library/Caches/com.apple.iconservices.store
sudo find /private/var/folders/ \( -name com.apple.dock.iconcache -or -name com.apple.iconservices \) -exec rm -rfv {} \; 2>/dev/null

/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister \
  -kill -r -domain local -domain user -domain system

killall Dock
killall Finder

These are advanced commands that modify system caches, so they should not be run casually. In many cases, simply restarting the Mac is enough to resolve stale icons.

Is PureMac Worth Using?

PureMac is interesting because it addresses one of the biggest problems with Mac cleaning software: trust.

A utility with Full Disk Access has enormous visibility into a user’s computer. That makes aggressive cleanup claims and opaque background services uncomfortable for many technically minded users.

PureMac’s open-source model gives users an opportunity to inspect how scanning and deletion work.

Its other major advantage is scope. It isn’t limited to uninstalling applications. Developers can use it to identify Xcode data, Docker storage, Homebrew caches, Node.js package caches, and other files that can quietly consume an SSD.

At the same time, PureMac isn’t something you should install and then blindly click Clean Everything.

No Mac cleaner can perfectly understand the value of every file on your computer. A preference file that looks unnecessary to an automated scanner might contain information you actually want to keep.

Final Verdict

PureMac is a compelling free Mac cleaner for users who value privacy, transparency, and control.

Its combination of application uninstalling, orphan detection, cache cleanup, developer-storage tools, and open-source code makes it more capable than a basic app uninstaller.

The biggest caveat is also the most important one: PureMac requires Full Disk Access, and some cleanup operations are irreversible once the Trash is emptied.

That means the safest way to use it is to treat PureMac as a file discovery and cleanup assistant, not an automatic “make my Mac faster” button.

Review the paths. Understand what you’re deleting. Keep backups of important data. And don’t confuse purgeable APFS storage with useless junk.

For users comfortable with that approach, PureMac offers something increasingly unusual in the Mac utility market: a powerful cleaner that doesn’t require a subscription, doesn’t rely on fear-based storage warnings, and makes its code available for inspection.

PureMac FAQ

Is PureMac free?

Yes. PureMac is distributed as free, open-source software under the MIT license.

Is PureMac safe?

PureMac includes several documented safeguards around path validation, system applications, and destructive operations. However, it requires Full Disk Access, so users should only install software they trust and should review files before deleting them.

Does PureMac permanently delete files?

PureMac’s documented cleanup workflow sends removed files to the macOS Trash rather than immediately unlinking them. Permanently emptying the Trash is a separate operation.

Does PureMac need an internet connection?

The application is designed to perform its cleaning functions locally and does not require a network connection for its core operation.

Does PureMac collect telemetry?

According to the project’s documentation, PureMac does not collect telemetry, usage analytics, or crash-reporting data.

Can PureMac uninstall applications completely?

PureMac can scan for application-related files across macOS and identify associated preferences, caches, containers, support files, and other leftovers. Users should still review the results because no automated matching system can guarantee that every discovered file is safe to remove.

Does PureMac actually make a Mac faster?

You should not expect dramatic performance improvements simply from deleting caches or old files. The main benefit is freeing storage and removing unnecessary data. PureMac deliberately avoids claiming that cleaning files will magically increase RAM or CPU performance.

What macOS version does PureMac support?

The project documentation specifies macOS 13 or later.