# launchd, the first process

> launchd is process 1 on every Mac, the parent of every daemon on the machine. Measured live: its real CPU cost, its folders, its log, and when to worry.

Source: https://www.ribbonmac.com/guides/launchd-mac · Updated 2026-11-18

Every process page in this series has said the same thing in passing. Parent process 1, and move on. Forty one pages of measurements, and the process on the other end of that sentence never got its own. This is that page, and the subject is bigger than all of the others put together: launchd is the first process macOS starts, the one the kernel hands the machine to, and every daemon this series has measured was started by it, watched by it, and will be cleaned up by it when it exits.

People arrive here from three directions. Activity Monitor, sorted by CPU, where a process with no apparent job sits near the top of every list because it has been there the longest. The LaunchAgents and LaunchDaemons folders, usually while removing something an installer left behind. Or a search for what com.apple.xpc.launchd means, usually because an error said so at boot. All three questions have the same answer, and it is a short one: this is the process that decides what runs.

## The process with no parent

The receipts, read only, from a MacBook Pro on macOS 27.0.1:

```
$ ps -Awwo pid,ppid,user,%cpu,rss,etime,time,comm
  PID  PPID USER  %CPU    RSS     ELAPSED    TIME COMMAND
    1     0 root   0.5  24016  27-23:16:03 322:24.95 /sbin/launchd
```

Everything about launchd is in that one row. Process id 1, because it was first. Parent id 0, because nothing started it: the kernel did. User root, because it runs as the machine itself, not as you. And an elapsed time equal to the machine's whole uptime, 27 days and 23 hours here, because the kernel booted it at 12:55 on 20 October and it has not stopped since. The only alternative to it running is the machine not running. If process 1 dies, the kernel panics by design.

The binary is small for what it does: 1,319,216 bytes at /sbin/launchd, built for arm64e only, signed by Apple on 23 August 2026 under the identifier com.apple.xpc.launchd. It carries 3,569 readable strings, which is lean, fewer than the Contacts daemon. The manager does not need much machinery of its own. It delegates everything, including the code signing checks that every spawned process goes through, and keeps only the registry, the schedule and the reaper's ledger.

## The one daemon Apple documents

Here is the twist that separates this page from the rest of the series: launchd has a proper manual page, 4,080 bytes of it, and it says what the daemon is in plainer words than any forum ever managed. During boot, it reads, launchd is invoked by the kernel to run as the first process on the system and to further bootstrap the rest of the system. You cannot invoke launchd directly.

The same page settles the vocabulary question that brings a lot of people here. In the launchd lexicon, it says, a daemon is, by definition, a system wide service of which there is one instance for all clients. An agent is a service that runs on a per-user basis. And daemons, the manual adds, should not attempt to display UI or interact directly with a user's login session. Any work that involves talking to a person belongs in an agent. That single paragraph is the difference between the two Launch folders in /Library, and it is why a job that needs to show a dialog must not run as root.

One more line deserves quoting whole: launchd also manages XPC services that are bundled within applications and frameworks on the system. XPC is the message system underneath nearly everything on a Mac, the way a process asks the system for a service by name and gets a channel back. launchd is not just the babysitter. It is the switchboard the babysitting runs on, which is why its identifier carries the xpc name and why its errors surface in places that look unrelated.

## Two domains, one process

launchctl, its command line tool, will print a snapshot of any domain it manages, and the two that matter are the system domain and your login domain. The system domain, read on the measured Mac:

```
type = system
service count = 444
active service count = 217
bringup time = 58 ms
maximum allowed shutdown time = 71 s
reload count = 57
creator = launchd[1]
```

Four hundred and forty four services are registered with the system domain, 217 of them actually running at the moment of reading, the rest waiting on demand. It brought that whole registry up in 58 milliseconds. The maximum allowed shutdown time, 71 seconds, is the politeness window the system gives everything under it when the machine is going down. And the reload count, 57, is how many times job definitions have been reloaded since boot, which is what installing software does to it.

The second domain is yours:

```
type = login
service count = 497
active service count = 245
creator = loginwindow[498]
session = Aqua
bringup time = 89 ms
```

Same idea, one layer up. Your login session is itself a launchd domain, created by loginwindow the moment you signed in, holding another 497 registered services of which 245 were running. This is the answer to the searches that say launchd mac gui: there are effectively two launchd namespaces on a logged in Mac, the root one and the Aqua one, and a process like [apsd](https://www.ribbonmac.com/guides/apsd-mac) lives in the first while [suggestd](https://www.ribbonmac.com/guides/suggestd-mac) lives in the second. That is also why the same daemon name can appear twice in Activity Monitor with different users beside it. They are in different domains, doing different halves of the same job. The strangest resident of the second kind is [universalaccessd](https://www.ribbonmac.com/guides/universalaccessd-mac), the Accessibility server: it lives at a /usr/sbin address like a system daemon, yet it runs in your login domain as you, and its job definition carries a LoginWindow session type too, one plist registered for both halves of the boot.

Down in that domain dump there is a nice confession of how deep this goes. The environment block includes SSH_AUTH_SOCK, the socket your shell uses to talk to the ssh agent, and it points into a per boot directory under /var/run whose name ends in /Listeners. launchd created that socket. It created the socket your terminal authentication runs on, holds it as a listening endpoint, and hands it to the right process when something connects. Sockets, sessions, services: all one registry.

## The five folders

The job list lives in plist files across five folders, and counting them on the measured Mac tells the whole story:

```
/System/Library/LaunchAgents    486 plists  Apple's, per user
/System/Library/LaunchDaemons   425 plists  Apple's, system wide as root
/Library/LaunchAgents             9 plists  third party, per user
/Library/LaunchDaemons            10 plists  third party, system wide
~/Library/LaunchAgents            8 plists  yours, your session only
```

Nine hundred and eleven of the 938 jobs on this machine are Apple's, and they are the same on every Mac running this version: [logd](https://www.ribbonmac.com/guides/logd-mac) the logging clerk, mDNSResponder the name resolver, the whole cast this series has been measuring. The 19 in /Library are third party, on this machine a device management suite and a couple of updaters, and that pair of folders is the one to check when software misbehaves, because it is the only place third parties are allowed to install system wide jobs. The eight in the home folder are the friendliest of the lot: agents that run only when their owner is logged in. Two belong to a browser's updater. The rest were installed by hand, a note syncer, a token refresher, a small watchdog. Nothing in that folder can run before you exist on the machine, which is exactly why the things that need to, daemons, live one level down in /Library instead.

Each plist is a job description with gates in it, and the gates are where the personality lives. RequiresExternalPower refuses to run on battery. RequiresUserInactivity waits until you have stopped typing. RunAtLoad fires the instant the definition is read. KeepAlive brings the job back whenever it dies, or, with SuccessfulExit false, keeps it from ever staying dead. The series has leaned on these for weeks: the photo daemon that refuses to burn your battery, the push daemon the system has promised never to reclaim, the suggestions daemon designed to be woken, used and put away. And one job books its own appointments: [chronod](https://www.ribbonmac.com/guides/chronod-mac), the widget timeline daemon, finishes a refresh and then registers a non repeating wake up event 1,549 seconds out, so launchd wakes it at the exact second the next widget is due. None of that behaviour lives in the daemons. It lives in a few keys in a plist launchd reads at boot.

## What it actually costs

Add up the whole run and the price of running everything is eleven and a half minutes a day. The TIME column above, 322 minutes and 25 seconds, is every second of processor time process 1 has spent across 27 days and 23 hours: starting jobs, reaping them, routing messages, holding sockets. That is heavier than logd's nine minutes, lighter than opendirectoryd's nineteen, and second among the quiet heavyweights this series has measured. At the moment of sampling it sat at 0.0 percent, then 0.1, at 25 MB of memory.

Where the time goes is visible in its own log, and it is not glamorous:

```
[pid/403 [codesign]:] created
[pid/403 [codesign]:] uncorking exec source upfront
[pid/440 [codesign]:] uncorking domain
[pid/403 [codesign]:] shutting down
[pid/403 [codesign]:] cleaning up
[system:] removing child: pid/403
```

That is one helper, named codesign, being created, uncorked, shut down, cleaned up and removed, and then another, and another. Half an hour of unified log held 7,536 lines from launchd and the overwhelming majority were this: spawn, verify, clean, repeat, three of them inside a single second. This is the honest answer to why launchd can look busy. It is not doing its own work. It is doing birth and death paperwork for other processes at speed, and when some misbehaving app starts and crashes in a loop, launchd is the clerk whose counter the loop runs through. A launchd that stays at high CPU for an hour on an idle Mac means something somewhere is spawning in a circle, and its log names the pid every time.

## The log, and the disk question

launchd keeps a log of its own, outside the unified logging system, at /var/log/com.apple.xpc.launchd/. It is modest: 18 MB on the measured Mac, one active file plus two rotations of about 7.3 MB each, so it is bounded and it cleans up after itself. The current file reads like a ledger:

```
internal event: EXITED, code = 0
service inactive: com.apple.ManagedClient
service state: not running
shutting down
cleaning up
removing child: pid/16074
```

That is one service's whole obituary, four lines and a deletion, and it is the grammar every service death is written in. If the question is disk rather than CPU, this directory plus the launchd databases in /var/db are the whole writable footprint, and neither grows without bound. The 18 MB is worth knowing about before you go hunting: on a machine with a spawning loop, this log is where the loop is written down.

## Runs, throttles and the ejector seat

Ask launchctl about any single job and you get its service record, and the fields tell you how the system really treats the things it runs. Two from this series:

```
$ launchctl print gui/$(id -u)/com.apple.suggestd | grep -E "runs|exit"
	runs = 3
	last exit reason = JETSAM_REASON_MEMORY_IDLE_EXIT
	exit timeout = 5

$ launchctl print system/com.apple.logd | grep -E "runs|exit"
	runs = 1
	last exit code = (never exited)
```

Two daemons, two philosophies. suggestd has been started three times, and its last exit reason, JETSAM_REASON_MEMORY_IDLE_EXIT, means the system threw it out on purpose to take its memory back, the same polite eviction [contactsd](https://www.ribbonmac.com/guides/contactsd-mac) gets, and will start it again the next time something asks. logd has run once and never exited, because the system would rather panic the machine than run without its logging clerk. launchd holds both arrangements at once, per job, from those same plists: exit timeouts, throttle intervals that stop a crashing job from respawning faster than every three seconds, minimum runtimes, and the jetsam pressure valve. When people search for launchd throttled processes, this is the machinery they have brushed against. It is not punishment. It is the system declining to let one broken job eat the schedule.

The registry even has a section for the jobs that are switched off. /var/db/com.apple.xpc.launchd/disabled.plist is launchd's own record of what must not run, and on a modern Mac it is a museum: the ftp daemon in there with its flag set to true, file sharing from another era, kept on disk and formally refused. That is the third state a job can be in. Not running and not waiting. Registered, and told no.

## What com.apple.xpc.launchd means in an error

The name shows up in two other places and both are benign to understand. First, the identifier: when Gatekeeper or a crash report or a boot argument says com.apple.xpc.launchd, that is just this binary's signing name, the xpc revealing that the process is also the message switchboard. Second, the phrase com apple xpc launchd failed lookup, which people meet at boot or in console dumps. It means a client asked the registry for a service by name and no live provider answered: the service is disabled, not yet registered at that point in boot, or gone with the app that provided it. It is a failed library query, not a failed component. On a healthy Mac the next line usually shows the asker carrying on, and the fix, when one is needed, is in the disabled database or the job's plist, not in launchd itself.

## And cron

The old scheduler is still on the machine, 271,260 bytes of it at /usr/sbin/cron, and it still works if you feed it a crontab. But the launchd manual page says the quiet part out loud: the traditional POSIX launching mechanisms, cron among them, should be considered deprecated and not suitable for new projects. The difference is on demand behaviour. cron checks the clock and runs what is due. A launchd job can start when a file changes, when a network port is asked for, when a Mach message arrives, or when the Mac wakes, and it can refuse to run on battery or wait until the user is idle. Everything measured in this series runs this way. None of it runs under cron, and the clock poller sits unused in /usr/sbin like a good typewriter.

## What Apple says, and does not

The Mac User Guide, fetched whole for this series, mentions launchd zero times across its entire table of contents. The pages that describe starting apps, managing login items, background software updates, all of it is there, and none of it names the process that does the starting. What is different here is that the omission does not matter: the manual page is authoritative, it is on your disk right now, and it documents the daemon, the vocabulary and the design intent in four kilobytes. This is the one process in the series where the primary source is Apple's own, and every quote on this page is from it or from the machine.

## The parent of everything in this series

This page closes a loop the series has been walking for weeks. [apsd](https://www.ribbonmac.com/guides/apsd-mac) holds one connection open to Apple so pushes can arrive. [logd](https://www.ribbonmac.com/guides/logd-mac) writes down what everything says. [suggestd](https://www.ribbonmac.com/guides/suggestd-mac) is woken, used and put away on a three second throttle. [opendirectoryd](https://www.ribbonmac.com/guides/opendirectoryd-mac) answers every question about who you are. Different jobs, different domains, one thing in common in every ps listing this series has ever printed: parent process 1. If your question is why some daemon exists at all, the answer is on this page. If your question is why it is busy, the answer is on its own.

## See for yourself

Every claim above came from commands like these, all read only:

```
$ ps -Awwo pid,ppid,user,%cpu,rss,etime,time,comm | head -2
$ ls -l /sbin/launchd && lipo -archs /sbin/launchd
$ codesign -dv /sbin/launchd
$ man launchd
$ launchctl print system/ | head -20
$ launchctl print gui/$(id -u)/ | head -20
$ ls /System/Library/LaunchAgents /System/Library/LaunchDaemons | wc -l
$ ls /Library/LaunchDaemons /Library/LaunchAgents ~/Library/LaunchAgents
$ launchctl print gui/$(id -u)/com.apple.suggestd | grep -E "runs|exit"
$ ls -lh /var/log/com.apple.xpc.launchd/
$ plutil -p /var/db/com.apple.xpc.launchd/disabled.plist
$ log show --last 30m --predicate 'process == "launchd"' --style compact | wc -l
```

Start with the man page. It is four kilobytes, it is Apple's own, and it explains more of what you are looking at in Activity Monitor than anything else on the machine.

## FAQ

### What is launchd on Mac?

It is the first process macOS starts, the one the kernel hands the machine to at boot, and it has process id 1 on every Mac that has ever booted. Every daemon, agent and login session on the machine is started by it, monitored by it and cleaned up by it, which is why nearly everything you see in Activity Monitor has 1 in the parent column. On the Mac measured here, a MacBook Pro on macOS 27.0.1, it has run for every second of 27 days without exiting, costs about eleven and a half minutes of processor time a day for all that spawning and reaping, and keeps a registry of 444 system services, 217 of them running at the moment of reading. It is the only daemon in this series that Apple documents properly, in a manual page of its own.

### Why is launchd using so much CPU?

Mostly it is not, and when it is, the work usually belongs to someone else. The measured cost here is about eleven and a half minutes of processor time a day at 25 MB of memory, sampling between 0.0 and 0.1 percent while this page was written. What pushes it up is spawn and cleanup churn: half an hour of its unified log held 7,536 lines, nearly all of them one helper process being created, uncorked, shut down and removed, three times in under a second. When launchd sits high in the CPU column for an hour, some process is being started and killed in a loop, and the log names which one. launchd is the messenger. The loop is the message.

### What are LaunchAgents and LaunchDaemons on a Mac?

They are the five folders launchd reads its job list from. The two folders inside /System/Library hold Apple's own jobs, 911 plists on the measured Mac, 486 agents that run per user and 425 daemons that run system wide as root. The matching pair under /Library is where third party software installs its jobs, 19 plists here. The fifth folder, in your own home Library, holds agents that only run when you are logged in, eight on this machine. Apple's own manual page draws the line: a daemon is a system wide service with one instance for all clients, an agent runs per user, and daemons should never show interface of their own.

### What is com.apple.xpc.launchd?

That is launchd's own code signing identifier. The binary at /sbin/launchd is signed by Apple under the name com.apple.xpc.launchd, because launchd is also the implementation of XPC, the message system processes use to talk to each other and to ask for services by name. When you see the name in an error, it usually means a lookup in that service registry failed, most often at boot or after something was disabled, and launchd keeps the list of disabled services in a database of its own at /var/db/com.apple.xpc.launchd/disabled.plist, where the old ftp daemon sits switched off. It also creates the listening sockets other processes use, including the ssh agent socket your shell is probably using right now.

### Can I quit or stop launchd?

No, and the system is built so you cannot. It is the only process with no parent: its parent id is 0, because the kernel started it directly, and the manual page is blunt about the rest, you cannot invoke launchd directly. There is no quit case to make either. If process 1 dies, the kernel panics, which is why in 27 days of measurements across this whole series of daemon pages, launchd is the one process that never appears in a crash report under its own name. What you can manage are its jobs, with launchctl, and that is the correct tool for anything you actually want to stop.

### Do Macs still use cron, or is launchd the replacement?

Both ship. cron is still sitting in /usr/sbin at 271,260 bytes and it still works, but Apple's manual page for launchd calls the traditional POSIX launching mechanisms deprecated and unsuitable for new work. The practical difference is on demand behaviour: cron wakes up and polls the clock, while a launchd job can start when a file changes, when a port is asked for, when a Mach message arrives or when the machine returns to the desk, and it can be told to refuse to run on battery. That is why everything in this series, from the photo analysis daemon to the logging clerk, runs under launchd and none of it runs under cron.
