PureMac macOS Cleaner Skill by ara.so — Daily 2026 Skills collection. PureMac is a free, native SwiftUI macOS application that cleans system junk, user caches, Xcode derived data, Homebrew caches, mail attachments, and purgeable APFS space. It is a privacy-respecting, open-source alternative to CleanMyMac X with no telemetry, no subscriptions, and no network calls. Install Homebrew (recommended) brew tap momenbasel/tap brew install --cask puremac Direct Download Download the latest .app from Releases , unzip, and drag to /Applications . Build from Source brew install xcodegen git clone https://github.com/momenbasel/PureMac.git cd PureMac xcodegen generate xcodebuild \ -project PureMac.xcodeproj \ -scheme PureMac \ -configuration Release \ -derivedDataPath build \ build open build/Build/Products/Release/PureMac.app Requirements: macOS 13.0+, Swift 5.9, Xcode 15+. Project Structure PureMac/ ├── PureMac/ │ ├── App/ │ │ └── PureMacApp.swift # App entry point │ ├── Views/ │ │ ├── ContentView.swift # Main window │ │ ├── ScanView.swift # Smart scan UI │ │ ├── CategoryDetailView.swift # Per-category drill-down │ │ └── SettingsView.swift # Schedule & preferences │ ├── Models/ │ │ ├── CleanCategory.swift # Category definitions │ │ └── ScanResult.swift # Scan result model │ ├── Services/ │ │ ├── ScannerService.swift # File scanning logic │ │ ├── CleanerService.swift # Deletion logic │ │ ├── SchedulerService.swift # Auto-clean scheduling │ │ └── PurgeableService.swift # APFS purgeable space │ └── Utilities/ │ └── FileSizeFormatter.swift ├── project.yml # XcodeGen spec └── CONTRIBUTING.md Core Concepts Clean Categories PureMac operates on named categories, each mapping to specific filesystem paths: Category Key Paths System Junk /Library/Caches , /Library/Logs , /tmp , ~/Library/Logs User Cache ~/Library/Caches , npm/pip/yarn/pnpm caches Mail Attachments ~/Library/Mail Downloads Trash ~/.Trash Large & Old Files ~/Downloads , ~/Documents , ~/Desktop (>100 MB or >1 year old) Purgeable Space APFS Time Machine snapshots via tmutil Xcode Junk DerivedData , Archives , CoreSimulator/Caches Homebrew Cache ~/Library/Caches/Homebrew Large & Old Files are never auto-selected — the user must explicitly choose items before cleaning. Working with the Codebase Adding a New Clean Category Define the category in CleanCategory.swift : // CleanCategory.swift enum CleanCategory : String , CaseIterable , Identifiable { case systemJunk = "System Junk" case userCache = "User Cache" case mailAttachments = "Mail Attachments" case trash = "Trash" case largeOldFiles = "Large & Old Files" case purgeableSpace = "Purgeable Space" case xcodeJunk = "Xcode Junk" case homebrewCache = "Homebrew Cache" // Add your new category here: case gradleCache = "Gradle Cache" var id : String { rawValue } var iconName : String { switch self { case . systemJunk : return "trash.circle" case . userCache : return "internaldrive" case . xcodeJunk : return "hammer" case . homebrewCache : return "shippingbox" case . gradleCache : return "archivebox" // new default : return "folder" } } } Add scanning logic in ScannerService.swift : // ScannerService.swift func scanCategory ( _ category : CleanCategory ) async throws -> ScanResult { switch category { case . gradleCache : return try await scanPaths ( [ FileManager . default . homeDirectoryForCurrentUser . appendingPathComponent ( ".gradle/caches" ) ] ) // ...existing cases default : throw ScannerError . unsupportedCategory } } private func scanPaths ( _ urls : [ URL ] ) async throws -> ScanResult { var files : [ ScannedFile ] = [ ] let fm = FileManager . default for url in urls { guard fm . fileExists ( atPath : url . path ) else { continue } let enumerator = fm . enumerator ( at : url , includingPropertiesForKeys : [ . fileSizeKey , . contentModificationDateKey ] , options : [ . skipsHiddenFiles ] ) while let fileURL = enumerator ? . nextObject ( ) as ? URL { let values = try fileURL . resourceValues ( forKeys : [ . fileSizeKey , . contentModificationDateKey ] ) let size = Int64 ( values . fileSize ?? 0 ) let modified = values . contentModificationDate ?? Date . distantPast files . append ( ScannedFile ( url : fileURL , size : size , modifiedDate : modified ) ) } } let totalBytes = files . reduce ( 0 ) { $0 + $1 . size } return ScanResult ( category : . gradleCache , files : files , totalBytes : totalBytes ) } Add cleaning logic in CleanerService.swift : // CleanerService.swift func clean ( _ result : ScanResult , selectedFiles : Set < URL

?

nil ) async throws -> Int64 { let filesToDelete = selectedFiles . map { Array ( $0 ) } ?? result . files . map ( \ . url ) var bytesFreed : Int64 = 0 let fm = FileManager . default for url in filesToDelete { do { let attrs = try fm . attributesOfItem ( atPath : url . path ) let size = attrs [ . size ] as ? Int64 ?? 0 try fm . removeItem ( at : url ) bytesFreed += size } catch { // Log but continue — don't abort on single-file failure print ( "Failed to delete ( url . lastPathComponent ) : ( error . localizedDescription ) " ) } } return bytesFreed } Scheduled Auto-Cleaning Configure via Settings → Schedule tab. Intervals: hourly, 3h, 6h, 12h, daily, weekly, biweekly, monthly. // SchedulerService.swift — how scheduling is implemented import UserNotifications class SchedulerService : ObservableObject { @AppStorage ( "schedulingEnabled" ) var schedulingEnabled : Bool = false @AppStorage ( "cleaningInterval" ) var cleaningInterval : String = "daily" @AppStorage ( "autoCleanAfterScan" ) var autoCleanAfterScan : Bool = false @AppStorage ( "autoPurgePurgeable" ) var autoPurgePurgeable : Bool = false private var timer : Timer ? func scheduleIfNeeded ( ) { timer ? . invalidate ( ) guard schedulingEnabled else { return } let interval = intervalSeconds ( for : cleaningInterval ) timer = Timer . scheduledTimer ( withTimeInterval : interval , repeats : true ) { [ weak self ] _ in Task { await self ? . runScheduledClean ( ) } } } private func intervalSeconds ( for key : String ) -> TimeInterval { switch key { case "hourly" : return 3_600 case "3h" : return 10_800 case "6h" : return 21_600 case "12h" : return 43_200 case "daily" : return 86_400 case "weekly" : return 604_800 case "biweekly" : return 1_209_600 case "monthly" : return 2_592_000 default : return 86_400 } } @MainActor private func runScheduledClean ( ) async { let scanner = ScannerService ( ) let cleaner = CleanerService ( ) for category in CleanCategory . allCases where category != . largeOldFiles { if let result = try ? await scanner . scanCategory ( category ) , autoCleanAfterScan { _ = try ? await cleaner . clean ( result ) } } if autoPurgePurgeable { try ? await PurgeableService . shared . purge ( ) } } } Enable scheduling programmatically: let scheduler = SchedulerService ( ) scheduler . cleaningInterval = "weekly" scheduler . autoCleanAfterScan = true scheduler . autoPurgePurgeable = false scheduler . schedulingEnabled = true scheduler . scheduleIfNeeded ( ) Purgeable Space (APFS Snapshots) PureMac uses tmutil to delete local Time Machine snapshots — this is the only operation requiring elevated privileges: // PurgeableService.swift import Foundation class PurgeableService { static let shared = PurgeableService ( ) func listSnapshots ( ) async throws -> [ String ] { let output = try await shell ( "tmutil listlocalsnapshots /" ) return output . split ( separator : "\n" ) . map ( String . init ) . filter { $0 . hasPrefix ( "com.apple.TimeMachine" ) } } func purge ( ) async throws { let snapshots = try await listSnapshots ( ) for snapshot in snapshots { try await shell ( "tmutil deletelocalsnapshots ( snapshot ) " ) } } @discardableResult private func shell ( _ command : String ) async throws -> String { try await withCheckedThrowingContinuation { continuation in let task = Process ( ) task . launchPath = "/bin/bash" task . arguments = [ "-c" , command ] let pipe = Pipe ( ) task . standardOutput = pipe task . terminationHandler = { _ in let data = pipe . fileHandleForReading . readDataToEndOfFile ( ) continuation . resume ( returning : String ( data : data , encoding : . utf8 ) ?? "" ) } do { try task . run ( ) } catch { continuation . resume ( throwing : error ) } } } } Xcode Cache Paths // Paths cleaned by the Xcode Junk category let home = FileManager . default . homeDirectoryForCurrentUser let xcodePaths : [ URL ] = [ home . appendingPathComponent ( "Library/Developer/Xcode/DerivedData" ) , home . appendingPathComponent ( "Library/Developer/Xcode/Archives" ) , home . appendingPathComponent ( "Library/Developer/CoreSimulator/Caches" ) , ] Scan these and safely delete their contents without removing the directories themselves. SwiftUI View Patterns Scan Progress View // Example: triggering a scan from a SwiftUI view struct ScanView : View { @StateObject private var scanner = ScannerService ( ) @State private var results : [ ScanResult ] = [ ] @State private var isScanning = false var body : some View { VStack { if isScanning { ProgressView ( "Scanning…" ) } else { Button ( "Smart Scan" ) { Task { await runScan ( ) } } } List ( results , id : \ . category ) { result in CategoryRow ( result : result ) } } } private func runScan ( ) async { isScanning = true results = [ ] for category in CleanCategory . allCases { if let result = try ? await scanner . scanCategory ( category ) { results . append ( result ) } } isScanning = false } } File Inspector (Click-to-Inspect) // Show files before deletion — users can deselect struct CategoryDetailView : View { let result : ScanResult @State private var selected : Set < URL

= [ ] @State private var cleaned = false var body : some View { List ( result . files , id : \ . url , selection : $selected ) { file in HStack { Image ( systemName : "doc" ) Text ( file . url . lastPathComponent ) Spacer ( ) Text ( ByteCountFormatter . string ( fromByteCount : file . size , countStyle : . file ) ) . foregroundStyle ( . secondary ) } } . toolbar { Button ( "Clean Selected" ) { Task { let cleaner = CleanerService ( ) _ = try ? await cleaner . clean ( result , selectedFiles : selected ) cleaned = true } } . disabled ( selected . isEmpty ) } } } Configuration (AppStorage Keys) All preferences are stored in UserDefaults via @AppStorage : Key Type Default Description schedulingEnabled Bool false Enable scheduled cleaning cleaningInterval String "daily" Interval key (see above) autoCleanAfterScan Bool false Auto-clean after scheduled scan autoPurgePurgeable Bool false Auto-purge APFS snapshots Read/write from anywhere: UserDefaults . standard . set ( true , forKey : "schedulingEnabled" ) UserDefaults . standard . set ( "weekly" , forKey : "cleaningInterval" ) Building & Testing

Generate Xcode project from project.yml

xcodegen generate

Build Release

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

Run tests

xcodebuild test \ -project PureMac.xcodeproj \ -scheme PureMac \ -destination 'platform=macOS'

Open built app

open build/Build/Products/Release/PureMac.app Contributing Fork and clone the repo. Run xcodegen generate to create the .xcodeproj . Create a feature branch: git checkout -b feature/gradle-cache-cleaning Follow existing patterns in ScannerService / CleanerService . Never add network calls, analytics SDKs, or telemetry of any kind. Large & Old Files must never be auto-selected for deletion. Open a PR against main . See CONTRIBUTING.md for full guidelines. Troubleshooting Problem Solution xcodegen: command not found brew install xcodegen App blocked by Gatekeeper The release build is notarized; if building from source, run xattr -cr PureMac.app Purgeable scan returns 0 bytes No local Time Machine snapshots exist — this is normal if TM is off Xcode paths not found Xcode has not been used yet or DerivedData was already cleared tmutil requires password Purgeable purge may prompt for admin credentials — this is expected macOS behavior Scheduled cleaning not triggering Ensure the app is running (it is not a background daemon); check Settings → Schedule Safety Guarantees Never deletes system-critical files or application bundles. Only removes caches, logs, temp files, and user-selected items. Large & Old Files require explicit user selection before deletion. Purgeable operations target only APFS Time Machine snapshots — not free space. All filesystem operations use FileManager.removeItem(at:) — no rm -rf shell calls for regular cleaning.