installd, the daemon that puts software on your Mac
installd is the macOS daemon that installs every package and App Store update. Measured live: its twin processes, two seconds of CPU a day, the receipts it writes, and its second job finding disk space.
By Chethan Kumar S N · Updated
Of all the lowercase names in Activity Monitor, installd is the one that has almost certainly put software on your Mac while you were watching something else. Every installer package you double click, every App Store update that applies itself in the background, every system update that restarts your machine: the part where files actually land in place runs through this daemon. The layers above it have their own owners: the daemon that checks for, downloads and stages those updates before installd ever starts a shift is softwareupdated, measured separately in this series. And yet installd is one of the quietest processes on the machine. On the Mac measured for this page, a 10 core MacBook Pro running macOS 27.0.1 with 27 days of uptime, the daemon had used barely more than a second of processor time in its current day and a half shift, holding under 2.5 MB of memory, root, parented by launchd, invisible unless you went looking.
There are in fact two of them, installd and system_installd, and their story is a good one: two nearly identical binaries, born of the same framework, dividing between them the most dangerous job on a personal computer, deciding what gets written where on your disk, and getting it wrong almost never.
Everything on this page was measured read only on that one Mac: both manual pages, both launch configurations, the receipts database, the daemon’s own strings, and two days of its logs. Nothing was quit, killed or changed while measuring, and every command is at the end if you want to repeat any of it.
One sentence of manual, twice
The manual page tells you what Apple thinks you need to know, and installd’s is a model of restraint. installd(8), dated January 31 2017, reads in full:
NAME installd - macOS software installation daemon
DESCRIPTION installd is used by the system during package installation. It should not be invoked manually.
SEE ALSO installer(8), pkgutil(1), system_installd(8)
That last line is the surprise. system_installd, the twin, has its own manual page too, same date, same wording, same see also list with the siblings swapped. Two daemons in this series so far shipped their own manual pages at all, spindump and usernoted. This one shipment adds a third and a fourth in a single stroke, and they say nothing more than the job and the warning: the system uses this, you should not.
The see also chain is doing quiet work as well. installer(8) is the command line tool that turns a pkg file into an install, pkgutil(1) is the tool that reads what installs left behind, and the two installd entries are the machinery in between. If you have ever wondered what a pkg file actually is, the answer is in that chain: instructions for this daemon.
Two twins, three hundred bytes apart
Both binaries live in the same folder, nested two levels inside the framework that owns them: /System/Library/PrivateFrameworks/PackageKit.framework/Resources/. installd is 220,448 bytes. system_installd is 220,144 bytes. Three hundred and four bytes apart, built on the same September 24 2026 day, both carrying three architectures including an Intel slice that still ships, both signed with Apple’s platform identifier 26.
The nesting is the same pattern the fseventsd page found, a daemon living inside the framework it serves, but the contents are a different story. fseventsd’s binary was a hollow shell with 476 strings because the code lived in the dyld shared cache. installd has 27 strings. Total. The entire life of the daemon, as text, is shorter than this paragraph:
installd: Starting installd: uid=%d, euid=%d installd: Couldn’t instantiate daemon installd: Unable to start listening for connections. installd: Exiting.
Alongside those sit a project tag, PackageKit-1525.0.1, and a handful of strings about its second job, which we will get to. Everything else, the staging, the verification, the receipts, the script running, lives one directory up in PackageKit itself. The binary is a vestibule; the building is the framework.
Why two doors into the same building? Division of privilege. installd takes the work that does not need root, and system_installd takes the work that does, writing into /Applications, /Library and the system locations a package can touch. A per user third instance exists as well: com.apple.installd.user, a launch agent running the same installd binary under your account, for installs that belong to you rather than the machine. The split means the all powerful installer is not woken for every trivial job, and the user scoped one never holds root rights at all.
The shifts, and what the doors say
The launch configurations for the two root daemons are as short as the manual page and tell the same story of restraint. Each registers two Mach services: its own name, and a CacheDelete variant. Each sets a spawn type of Adaptive, the class launchd gives workers that should take resources when summoned and give them back after, in contrast to usernoted, which is Interactive because a notification must never wait. Each enables pressured exit, which is a promise to the system: I may be asked to leave when memory is wanted elsewhere, and I will.
There is no KeepAlive. There is no RunAtLoad. Of every daemon profiled in this series, this is the first that is not kept alive at all. It is a tradesman with a pager rather than a guard on post.
launchd’s own report for the pair, 27 days into this Mac’s uptime, reads like a work log. installd: 39 runs, last woken by an incoming message, ipc (mach), last exit under memory pressure, JETSAM_REASON_MEMORY_IDLE_EXIT, minimum shift length 10 seconds. system_installd: 38 runs, same story. Roughly one shift every two days each, summoned when something installs, released when idle. Both were on shift at the moment of measuring, which means something installed recently, and indeed the receipts say so: Microsoft Teams had updated itself two days earlier, at 14:05 on a Friday afternoon, and the daemons had stayed resident since, waiting in case more work came.
The cost, measured honestly
Here is the number that answers the search that brought most people here. In the current shift, a day and eight hours long, installd used 1.02 seconds of processor time and system_installd 1.28 seconds. Together: about two and a half seconds of CPU in 32 hours, on a machine with ten cores. Resident memory: 1.8 MB and 2.4 MB. Among the smallest daemons measured in this series, awake or asleep.
So why does installd have a reputation for eating CPU? Because when it works, it really works, and the work is not its own vanity. Installing is decompressing gigabytes, verifying signatures against the trust machinery, moving thousands of files atomically, running the package’s own scripts, then writing the receipt. The proof is on this Mac’s disk: a processor budget report in /Library/Logs/DiagnosticReports, named installd and timestamped during a recent update, in which the daemon held half a core for three minutes straight. The system noticed, wrote the report, took no action, and the daemon finished the install and went back to bed. That is installd at full burn: three minutes at half a core, once, per update, and it belongs on the running slow page’s list of daemons you can safely stop worrying about.
The spike you catch in Activity Monitor is almost always one of two things: an App Store auto update applying itself in a burst, or an installer you launched doing its job. Neither is a fault. If the CPU column stays lit for an hour with nothing installing, something is stuck mid install, and the log command at the end of this page names the package.
What installing actually looks like
Follow the machinery far enough and you find the two ledgers macOS keeps of everything installd has ever done.
The first is the receipts database, /var/db/receipts. This Mac holds 48 receipt files covering 52 packages, and each is a pair: a plist saying what was installed and when, and a BOM, a bill of materials, listing every file. The most recent entries read like a fortnight of ordinary life: a Teams update on November 14, a VPN client on November 12. The pkgutil command from the manual’s see also chain reads this ledger; pkgutil --pkgs lists it, and pkgutil --pkg-info names the install time and volume of any entry. Uninstallers that do a clean job, the kind the uninstalling apps page tells you to prefer, are reading the same BOMs to know what to remove.
The second ledger is the framework’s own folder, which reads like a workshop wall. Alongside the two daemons sit install_monitor, deferred_install with a shell script, and DeferredInstallFixup, the crew that handles packages whose pieces install at different times, like components that must wait for a restart. Three plists named InstallScriptActions, InstallScriptMutations and InstallScriptTries record what package scripts did, changed, and attempted. And one file dwarfs them all: PKInstallError.loctable, 162,719 bytes of error strings translated into dozens of languages. Every “installation failed” dialog you have ever squinted at came out of this catalog. A few of the English entries:
100 Authorisation is required to install the packages. 102 The package is untrusted. 107 There is not enough space available to install the software. 110 An error occurred while extracting files from the package. 112 An error occurred while running scripts from the package.
That is the wall every failed install has hit since 2017, and it is 160 KB long, which tells you how many ways a package can go wrong without any of them being your fault.
The second job: knowing what can be deleted
Now the part almost nobody knows, measured in two days of logs. installd has a second service, com.apple.installd.CacheDelete, and it answers to another daemon called deleted, from the CacheDelete framework, which is the system’s disk space reclaimer.
Roughly once an hour, deleted connects to installd and asks a question: estimateOfPurgeableSpaceForSandboxesOnVolume. installd answers with the strings it carries for exactly this: Purgeable Orphaned Space is, followed by a number, and when space is actually needed it runs the purge, startPurgeOfSandboxesOnVolume, and reports Purged Orphaned Space in return. In plain words: when your Mac is short on disk, installd is the one that knows which abandoned app containers and leftovers can be safely deleted, because it is the one that put them there. If you have ever watched the storage bar in System Settings free up space by itself, this hourly handshake is part of the machinery doing it, and the storage full page covers the rest of that crew.
Two days of logs for both installd processes came to 165 lines. Almost all of them were this hourly handshake: a connection arriving, a role number, a purgeable estimate, a disconnect. For a daemon whose day job can burn half a core moving gigabytes, the log of its ordinary life is one polite exchange an hour.
The neighbourhood
Count the launch jobs on this Mac with install in the name and you find a family of six, each a different trade:
- installd and system_installd, the pair on this page, PackageKit’s tradesmen
- com.apple.installd.user, the per user instance for installs that belong to your account, the same binary in a launch agent
- appinstalld, which lives in a different framework entirely, MobileInstallation, and whose lineage is the iPhone: installing App Store apps is the same machinery that runs on iOS, which is why people poking through logs on both platforms meet names like com.apple.mobile.installd and reasonably wonder if they are the same thing. They are cousins. appinstalld even has its own reserved system account, _appinstalld, home directory /var/db/appinstalld, empty on this Mac
- uninstalld, from a framework Apple ships called, plainly, Uninstall. There is an entire framework for taking software off, which is a comfort to anyone who has read the uninstalling page and wondered why leftovers are such a fight
- bootinstalld in /usr/libexec, the specialist that handles installs wired into early boot
And one neighbour connection worth making: when installd hangs or blows a CPU budget, the system calls spindump to sample it and write the report. That is how the processor budget report quoted earlier came to exist. The installer and the reporter are colleagues.
The installer you already know
Apple’s own user guidance for installing apps is a short page in the Mac User Guide, Install and uninstall apps from the internet or a disc. Its instructions for the common case: in the Downloads folder, double click the disk image or package file, which it describes as looking like an open box, and follow the onscreen instructions if the installer does not open itself. That one sentence routes you into one of two doors. The open box is a package, and its installer hands the job to installd. The disk image is the other door, and it has no daemon at all: you drag the app where you want it, and the machinery involved is you.
Ribbon takes the second door, on purpose. It ships as a notarized DMG you drag into Applications, no package, no scripts, no receipt, nothing for installd to do, and the trustd page covers the notarization check that happens the first time you open it instead. The app itself is about what is on your screen after all those installs: every window full size on one scrolling strip, nothing stacked, nothing shrunk, the window you want one swipe away. It is $15, once, for up to 3 Macs, with a full refund within 10 days, and it runs on macOS 14 Sonoma and later on Apple silicon and Intel Macs. There is a browser demo of the strip if you want to feel it before installing anything.
Is it a virus, and can you quit it
The virus question has a five second answer, and the checks are worth knowing rather than trusting. The real daemons live inside the PackageKit framework on the sealed system volume, are signed with Apple’s platform identifier 26, run as root with launchd as parent, and have carried the same one line manual page since 2017. A process with this name running from Downloads, a browser profile, or your own Library, with any parent other than launchd, would be the moment to look closer. That is not what the real one looks like.
Quitting is beside the point, because it quits itself: 38 and 39 times in 27 days on this Mac, released by the system whenever memory pressure came and nothing was installing. There is no off switch in System Settings and there should not be. The switches that exist are upstream, and they are the ones people actually want when they go looking: App Store settings, where automatic downloads and automatic updates can each be turned off, and the softwareupdate command’s schedule setting for system updates. Turn those off and installd’s pager simply stops ringing. What you should never do is force quit it mid shift: an interrupted install is the one scenario the staging machinery exists to survive, but letting the shift finish is cheaper than recovering from interrupting it.
The short version
installd is the installer: two twin daemons 304 bytes apart, summoned by the knock of a package, doing the privileged half of the most dangerous routine job on a personal computer, then dismissed by memory pressure until next time. It costs seconds of CPU a week, keeps a receipt of everything it has ever done in /var/db/receipts, answers an hourly question about what disk space can be reclaimed, and has said the same one line about itself since 2017. When it lights up your CPU column, an update is being installed, and when the light stays on, the install log names the package. That is the whole story, and it is a well run one.
How to look at your own
Everything above came from read only commands:
ps -Awwo pid,ppid,user,%cpu,rss,etime,command | grep "[i]nstalld"
man installd && man system_installd
plutil -p /System/Library/LaunchDaemons/com.apple.installd.plist
launchctl print system/com.apple.installd | grep -E "runs|pid|state|exit"
ls -l /System/Library/PrivateFrameworks/PackageKit.framework/Resources/
strings /System/Library/PrivateFrameworks/PackageKit.framework/Resources/installd
ls -lt /var/db/receipts | head
pkgutil --pkgs | wc -l
log show --last 2d --predicate 'process == "installd" OR process == "system_installd"' | grep -v cache_delete | head -30
The launchctl line is the honest one: runs, last exit reason, and the pid tell you how many shifts the daemon has worked since boot. The receipts line is the interesting one, because it is your Mac’s own install history, stamped to the minute, and the newest file in it explains why the daemons were on shift when you looked.
Questions
What is installd on Mac?
It is the daemon macOS uses to install software. When an installer package finishes downloading, when the App Store applies an update, or when a system update runs its scripts, the work of moving files into place, checking signatures, running the package's own scripts and writing the receipt is done by installd. Its manual entry, installd(8), dated January 2017, says exactly that in one line: installd is used by the system during package installation. On the Mac measured here there are two of them, installd and system_installd, twins 304 bytes apart in size, and between them they have used about two and a half seconds of processor time in their current day and a half of running.
What is system_installd, and why are there two?
system_installd is the elevated half of the pair. installd handles work that does not need root rights, and system_installd handles the parts that do, like writing into /Applications, /Library and the system locations a package touches. Both binaries live side by side inside the PackageKit framework at /System/Library/PrivateFrameworks/PackageKit.framework/Resources, both were built on the same September 2026 day, and both ship their own manual page with identical wording, which is a rarity: most daemons on the Mac have no manual page at all. There is also a per user copy of the same job, com.apple.installd.user, which runs the same installd binary under your account for user scoped installs.
Why is installd using so much CPU?
Because something is being installed, and installing is real work: decompressing gigabytes, verifying code signatures, moving thousands of files and running the package's scripts. The daemon itself is nearly free when idle. Measured over a day and a half shift on a 10 core MacBook Pro, installd had used 1.02 seconds of processor time and system_installd 1.28 seconds, together about two and a half seconds. When it does spike, there is usually paper trail: this Mac holds a processor budget report named after installd, written on a day it spent three minutes at half a core while an update ran. App Store automatic updates arrive in bursts, which is why the spike shows up when you were not installing anything you remember. If it stays busy for hours with nothing installing, check Activity Monitor for the client, and read the install log named in the commands section below.
Is installd a virus or malware?
No. It is Apple's own code. The copies measured here live inside the PackageKit framework on the sealed system volume, are signed with Apple's platform identifier 26, run as root with launchd, process ID 1, as their parent, and ship with manual pages that have carried the same wording since 2017. The name does attract imposters in search results because people search it when an install fails, so the checks are worth knowing: the real one's path contains PackageKit.framework, its parent is launchd, and its user is root. Anything calling itself installd from a Downloads folder, a browser profile or your own Library, with any other parent, is not this daemon.
Can I quit or disable installd?
It quits itself all the time, and that is the design. Unlike notification or network daemons that must never die, installd has no keep alive setting: launchd starts it when an install knocks, it works, and when memory pressure comes it exits quietly, which on this Mac had happened 38 and 39 times across 27 days of uptime, roughly one shift every two days. There is no switch in System Settings that disables it, because disabling the thing that installs your updates is not a setting anyone should want. The lever you do have is upstream: App Store settings turn off automatic downloads and automatic updates, and the softwareupdate command has a schedule switch, so nothing knocks on installd's door in the first place. Never force quit it mid install; let the shift finish.
Ready? Buy Ribbon for $15, or read all the guides.