HeartbeatHocusFocusFilesMacHyperTile
Guide

distnoted, the daemon that shows up twenty-three times

The relay that carries distributed notifications between apps on macOS, why twenty-plus copies run at once, and what one quiet hour of its logs looks like.

By Chethan Kumar S N · Updated

Of all the lowercase names in Activity Monitor, distnoted is the one people count. There is the copy running as you. There is one under root. There are copies under _windowserver, _locationd, _coreaudiod, _spotlight, _applepay, and a dozen other reserved accounts you have never logged in as. On the Mac measured for this page, a 10-core MacBook Pro running macOS 27.0.1 with 26 days of uptime, the count is 23: 21 copies of /usr/sbin/distnoted plus two more inside iOS simulator runtimes. None of them is a bug. All of them together cost about 34 MB of memory and under two minutes of processor time a day.

This page is the full answer to the name, built the way the other process pages in this series are built: from the daemon’s own manual entry, its own launch configuration, its own binary, and an hour of its own logs, all measured read only on one Mac. Nothing was quit, killed or changed while measuring, and every command used is at the end if you want to repeat any of it.

The name decodes first. It is distributed note d, a daemon for distributed notifications. A distributed notification is a named message that one process posts and any number of other processes can receive, without the sender knowing who is listening, and without any direct connection between them. It is the macOS equivalent of a building’s public address system: you announce that the date preferences changed, and anyone who cares hears it, and nobody who does not.

Nothing about it reaches your screen. The things people mean when they say notifications, the banners, the Dock badges, the list you see when you click the clock, belong to a different daemon entirely, usernoted, which runs as you rather than as a relay and keeps a database of everything it has handed you. The two get confused because they share a word, and they are about as alike as a telephone exchange and a letterbox.

The two-terminal proof

The mechanism is easiest to believe when you watch it work. Distributed notifications are a developer interface, so the test needs two small programs: one that registers for a made-up name and waits, and one that posts to that name a second later. Both were compiled and run as two separate processes on this Mac, each with its own process ID, using the Swift snippet below.

// Terminal 1: the observer
import Foundation
let nc = DistributedNotificationCenter.default()
nc.addObserver(
    forName: Notification.Name("com.example.distnoteTest"),
    object: nil, queue: nil
) { n in print("OBSERVED:", n.name.rawValue, n.userInfo ?? [:]) }
while true { RunLoop.current.run(until: .distantFuture) }

// Terminal 2: the poster
import Foundation
DistributedNotificationCenter.default().postNotificationName(
    Notification.Name("com.example.distnoteTest"),
    object: "test", userInfo: ["hello": "from the other process"],
    deliverImmediately: true
)

The observer printed its line about a second and a half after the poster ran, name and payload intact, in a process that had no connection to the poster except the notification name. The user session’s distnoted wrote both halves of the exchange into the unified log, and its own lines are the receipt:

New connection from .../swift-frontend (62565)
register name: com.example.distnoteTest object: kCFNotificationAnyObject token: 100000000 pid: 62565
New connection from .../swift-frontend (62566)

One line for the observer connecting, one for it registering the name it wants to hear, one for the poster connecting. That is the whole service: connect, register names, receive whatever matches, post whatever you like. Everything else in this page is what that looks like at the scale of a whole Mac.

There is a small piece of history hiding in that snippet. The class every macOS developer knows is NSDistributedNotificationCenter, and it still exists, but in the current SDK the Swift compiler now refuses the old name outright and prints: ‘NSDistributedNotificationCenter’ has been renamed to ‘DistributedNotificationCenter’. The interface’s own note still warns that these objects should not be used to send notifications between threads within the same task, which is the boundary of the design: distributed notifications are for between processes, and ordinary notifications are for within one.

Why there are twenty-odd of them

The count is the part that sends people searching, and the answer is in two plain property lists on the sealed system volume. There is no single big distnoted. There is a system daemon and a per-session agent:

/System/Library/LaunchDaemons/com.apple.distnoted.xpc.daemon.plist
  UserName: _distnote      argument: daemon
  MachServices: com.apple.distributed_notifications@0v3
                com.apple.distributed_notifications@1v3
  PublishesEvents: com.apple.distnoted.matching.trusted (RequireTrusted)

/System/Library/LaunchAgents/com.apple.distnoted.xpc.agent.plist
  LimitLoadToSessionType: Background     argument: agent
  MachServices: com.apple.distributed_notifications@Uv3
  KeepAlive: true    EnablePressuredExit: false
  EnvironmentVariables: MallocMaxMagazines = 1

The agent is the interesting one. It loads once per background session, and macOS gives nearly every service account its own background session, because those accounts run agents of their own that may want to post or hear notifications. So the copy running as _windowserver serves WindowServer’s session, the copy as _coreaudiod serves Core Audio’s, whose own daemon is covered in the coreaudiod page, and so on. The Mach service names spell the architecture out: @Uv3, with the U, is the per-user, per-session service, while @0v3 and @1v3 are the two system-wide domains the daemon owns under the _distnote account.

On this Mac, the 21 system-binary copies break down like this:

Copy runs asResident memoryWhat its session belongs to
chethankumar (you)5,376 KByour background session, the busiest by far
_distnote2,416 KBthe system daemon, the @0/@1 domains
root1,456 KBroot’s background session
_windowserver1,216 KBeverything drawn on screen
_nsurlsessiond, _fpsd, _spotlight, _applepay and 13 moreabout 1.2 to 1.3 MB eachone each per service account

Add the two simulator copies, one per installed iOS runtime, each running from inside its RuntimeRoot, and the Activity Monitor count lands at 23. If you have never installed a simulator runtime, expect roughly one row per service account plus your own and root’s.

Two of those names deserve a closer look. The _distnote account exists for exactly this daemon: user ID 241, group ID 241, real name DistNote, shell /usr/bin/false, so it can sign in to nothing and own nothing but this job. And the plist line MallocMaxMagazines = 1 is a small piece of engineering honesty: it tells the allocator to use a single magazine, trading a little speed for a smaller footprint, in a daemon that knows it will be instantiated twenty times over.

Three sentences from 2005

The manual entry is one of the shortest on the Mac, and one of the oldest still standing. /usr/share/man/man8/distnoted.8 is 355 bytes long, carries a footer of Mac OS X, and is dated July 1, 2005, which makes it older than the Intel transition. The whole of it:

distnoted - distributed notification server

distnoted provides distributed notification services.

There are no configuration options to distnoted. Users should not run distnoted manually.

That is the entire public interface, and unusually for this series, it is also accurate. There really are no configuration options: no preferences domain, no settings file, no launch argument beyond the daemon and agent roles. It is a fixed function, twenty years old, still exactly the right size.

What Apple’s user facing help does not do is name it anywhere. The Activity Monitor guide, fetched in full for this page at 552 KB, contains the word distnoted zero times, the same omission the trustd and rapportd pages found for their subjects. Apple documents the Activity Monitor app in detail and leaves every daemon it lists unexplained, which is why a name this ordinary ends up in so many searches.

One quiet hour, counted

To see what the daemon actually does, the unified log for every distnoted process was pulled for one hour of light use, a browser open, background sync running, nothing stressed. The total was 650 lines: 491 from the user session copy, 156 from the system daemon, and 3 from root’s. Those lines split into two kinds, connections and registrations, and the counts describe the job precisely: 92 new connections were opened in the hour, and 367 names were registered through them, because a client connects once and then registers for every name it wants to hear.

The connection log is a cast list of a running Mac. In one hour, the user session copy took connections from:

ClientConnections in one hourWhat it is
system_profiler59hardware inventory, polled about once a minute on this managed Mac
ReportCrashService6crash reporting waking up alongside its parent
mdmclient5device management checking in
AppSSODaemon and AppSSOAgent1 eachsingle sign-on account plumbing
iCloudHelper1iCloud bookkeeping
AddressBookManager, AddressBookSourceSync1 eachcontacts sync
MailCacheDelete and Safari’s CacheDeleteExtension1 eachstorage housekeeping
biomesyncd, parsec-fbf, RemoteManagementAgent, others1 eachsystem services posting status
a third-party app’s helper1any app can use the bus

Two honest notes on that table. First, the system_profiler row is a property of this particular Mac, which is enrolled in device management and takes an inventory scan about once an hour; an unmanaged Mac will not have it, and the frequency is set by the management software, not by distnoted. Second, the third-party row is the point of the design: the bus is public, any process may connect, and the daemon treats a stock Apple helper and someone’s menu bar app exactly the same.

Across all of that, the busiest copy on the machine, yours, spent 784 seconds of processor time in 26 days. That is about 30 seconds a day, for a process that sat in the middle of roughly a hundred connections and several hundred deliveries a day. The 1.7 minutes a day figure for all copies combined, about 0.12 per cent of one core, is the honest cost of the building’s public address system.

What 331 strings say about the job

The binary itself is small, 440,064 bytes, built for four architectures, signed by Apple in August 2026, and it contains only 331 printable strings, which for a system daemon is almost ascetic. But the ones it does carry describe the work exactly.

Seven notification names are compiled straight into the binary, and they are all preferences changes:

AppleDatePreferencesChangedNotification
AppleLanguagePreferencesChangedNotification
AppleMeasurementSystemPreferencesChangedNotification
AppleNumberPreferencesChangedNotification
AppleTemperatureUnitPreferencesChangedNotification
AppleTextBehaviorPreferencesChangedNotification
AppleTimePreferencesChangedNotification

That list is the classic use of the whole mechanism, older than the Mac it runs on: you change your date format or your language in System Settings, and every running app that cares, which is most of them, needs to redraw and reformat. Nothing restarts. One notification goes out, everything listening adapts. A string like com.apple.distnote.locale_changed belongs to the same family.

The delivery rules are there too, in the vocabulary the daemon uses internally: Coalesce, for collapsing a flood of identical posts into fewer deliveries, and DeliverImmediately and PostToAllSessions, the two options a sender can pick. PostToAllSessions is the one that reaches across the per-session boundary the launch jobs draw, which is why the option exists at all.

And the defences are spelled out in log-format strings, ready to fire:

%s (%d) will not receive posted notification (name: %@),
  outbound queue is too large (%d)

%s (%d) is not trusted and does not have required entitlement
  key '%@'. Process will not receive posted notification (%@).

The first is flood control: a client that never drains its queue stops receiving, so one misbehaving listener cannot balloon the daemon’s memory. The second is the trusted audience gate, the enforcement behind that RequireTrusted event in the daemon’s plist: some notification names are reserved for listeners holding a specific entitlement, so an ordinary process cannot sit on the bus and collect, for example, security-relevant broadcasts it has no business seeing. The posting path even carries the words to match, one handler named handlePostWithName:object:userInfo:msg:audience:entitlementKey, audience and entitlement key as first-class citizens of every single post.

The cost, measured honestly

MeasurementValue
Copies running23 (21 system binary, 2 simulator runtimes)
Total resident memory33.8 MB across all copies
Typical system copyabout 1.2 to 1.3 MB
Total CPU over 26 days44.6 minutes
Per day, all copiesabout 1.7 minutes, 0.12 per cent of one core
Restarts since bootnone: every copy runs = 1, never exited
launchd reasonsimmediate reason speculative, minimum runtime 10 s, exit timeout 5 s

For contrast inside the same series, bluetoothd spends closer to ten minutes of processor time a day and writes five log lines a second doing it, while a single trustd copy costs more CPU than all twenty-three distnoted rows put together. This daemon is a message relay with a tiny per-message cost, and its numbers should be boring. If they are not, the log census below will show the client that is making them interesting.

One launchd detail rounds out the picture: both jobs run with EnablePressuredExit set to false, the opposite of cloudd, which the system reclaims at will. A relay that must always answer the door cannot be allowed to vanish whenever memory gets tight, and launchd’s own print output for both jobs shows the consequence: started once, speculatively, at boot, still running 26 days later.

How to look at your own

Everything above came from read only commands that any Mac can run:

ps -Ao pid,ppid,user,%cpu,rss,time,etime,comm | grep [d]istnoted
plutil -p /System/Library/LaunchDaemons/com.apple.distnoted.xpc.daemon.plist
plutil -p /System/Library/LaunchAgents/com.apple.distnoted.xpc.agent.plist
launchctl print user/501/com.apple.distnoted.xpc.agent
log show --last 1h --predicate 'process == "distnoted"' | wc -l
log show --last 1h --predicate 'process == "distnoted"' | grep "New connection from" | sort | uniq -c | sort -rn

Your count will differ from 23 with your installed simulator runtimes and your Mac’s list of active service accounts, and a smaller number is normal, not a sign that something is missing. The health check is the last command: the client table it prints should be dominated by names you can account for, system tools and your own apps, each connecting a handful of times an hour. One client appearing hundreds of times, or a total line count that climbs hour over hour with no activity, is the signature of a busy poster, and that process is the thing to look at, not the messenger.

Where window managers fit

This page is about plumbing; the complaint that brings people to a window manager is about space. They meet in one place: a Mac is full of machinery that runs whether or not you ever see it, and the good kind is machinery you never have to think about. Twenty-three copies of a 2005 three-sentence daemon quietly wiring every process to every other one is the good kind.

Ribbon is a window manager with the same instinct, keep things visible instead of stacked. Windows stay full size on a single scrolling strip, so the window you want is one swipe away and nothing hides behind anything. 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.

The short version

distnoted is the distributed notification server: one small binary, launched as a system daemon under the reserved _distnote account and again as a background agent for every login session on the Mac, which is why Activity Monitor shows a dozen or two dozen rows of it. It has a manual page from 2005 that is three sentences long and completely honest, no options, do not run it yourself, and it has no settings of any kind to break or tune.

Its work is invisible by design: apps connect, register names, and post, and the daemon delivers, coalescing floods, capping lazy listeners, and gating the sensitive names behind entitlement checks. Measured over a quiet hour it took 92 connections from a cast of system services and ordinary apps, and measured over 26 days the entire fleet cost 44 minutes of processor time, a rounding error on one core.

You cannot disable it, should not kill it, and have no reason to want either. If a distnoted row ever misbehaves, the daemon is the wrong suspect: open its log, count the connections, and the process at the top of that table is your answer.

Questions

What is distnoted on Mac?

It is the server behind distributed notifications, the macOS mechanism that lets one process broadcast a named message and any number of other processes receive it. When an app changes a setting, picks up a locale change, or wants to tell every other interested process that something happened, it posts a notification to distnoted, and the daemon relays it to whoever registered for that name. Apple's own manual entry for it is three sentences long and dates from July 2005: distnoted provides distributed notification services, there are no configuration options, and users should not run it manually. On the Mac measured here it works constantly but cheaply, under two minutes of processor time a day across every copy combined.

Why are there so many distnoted processes in Activity Monitor?

Because it runs one copy per login session, and macOS runs login sessions for service accounts too. There is a per-user agent, launched with the same binary and the single argument agent, for every user with a background session: yours, root, and reserved accounts like _windowserver, _locationd, _coreaudiod, _spotlight, _applepay and more. On this Mac that is 20 copies from the system binary plus one system daemon under its own reserved user _distnote, and if you build iOS apps, each simulator runtime adds another from its own RuntimeRoot, bringing the count to 23. This is the architecture, not an infection: the launch job's own configuration says LimitLoadToSessionType Background and exposes a per-user service named com.apple.distributed_notifications@Uv3, one per session.

Is distnoted a virus or malware?

No. It is Apple's own code on the sealed system volume at /usr/sbin/distnoted, signed by Apple's system authority, and the system copy runs as a reserved account named _distnote with user ID 241 and no login shell, which is the opposite arrangement from anything malware uses. Its manual page has shipped since 2005. The reason it draws searches is presentation: a lowercase name you never installed, appearing many times under users you have never heard of, and Apple's own Activity Monitor guide never says the word distnoted anywhere, so the app that lists it offers no explanation for it.

Can I quit or disable distnoted?

There is no supported switch, and nothing would improve if there were. Its launch configuration sets KeepAlive to true, and on this Mac both the system daemon and the user agent have run exactly once since boot with no exit at all, which is what a relay that must always answer looks like. Killing a copy buys seconds before launchd starts it again, and the manual's own advice is that users should not run it manually, which cuts both ways. It also has no settings to tune: no preferences pane, no defaults domain of its own, no configuration file. The honest answer for a misbehaving copy is the same as for most daemons in this series: it is a messenger, so look at what is sending the traffic, using the log command in the page below.

Why would distnoted use high CPU or memory?

Almost never because of the daemon itself. Across all 23 copies on the Mac measured here, the total was about 44 minutes of processor time over 26 days of uptime, roughly 1.7 minutes a day, about 0.12 per cent of one core, and 33.8 MB of memory combined. Each system copy idles at around 1.2 to 1.5 MB. The one scenario that plausibly loads it is a runaway client posting floods of notifications, and the daemon has its own defence compiled in: a string in the binary says a process will not receive a posted notification when its outbound queue is too large. Persistent high CPU from a distnoted row means finding the client that never stops posting, and the one-hour log census below shows how to see exactly that.

Ready? Buy Ribbon for $15, or read all the guides.