# netbiosd, the daemon that answers to a name from 1987

> netbiosd is the NetBIOS daemon on macOS. Measured live: the 1987 name protocol it serves, the two UDP ports it holds open, and the firewall prompt it explains.

Source: https://www.ribbonmac.com/guides/netbiosd-mac · Updated 2026-11-17

Netbiosd is the process in Activity Monitor with the name nobody can place. It is not the firewall, though the firewall may ask about it. It is not file sharing, though it works next to it. It is the registrar for a naming protocol that predates the web, still running on every Mac in 2026 because some networks never fully retired it.

The name to say out loud is NetBIOS, short for Network Basic Input Output System. It is how machines on a local network found each other by name in the era of coax cable and DOS workgroups, and its TCP and UDP embodiment was written down in RFC 1001 and RFC 1002 in 1987. macOS carries a daemon whose whole job is that protocol's name layer: registering your Mac's NetBIOS name, defending it when another machine claims the same one, and browsing the workgroup lists that old networks still broadcast.

Like spindump and usernoted before it, in this series of process pages, netbiosd ships with its own manual page. netbiosd(8), dated 4 November 2009, is unusually specific about the job: register and defend names, browse and scavenge them, and hand what it finds to mDNSResponder, the daemon behind Bonjour. The page also notes the utility first appeared in Mac OS 10.7, which means the man page predates the OS that shipped it. Apple wrote this documentation before Lion existed, and has carried both forward for fifteen years.

Everything below was measured on a stock Mac running macOS 27.0.1 on Apple silicon, up 27 days at the time of reading, with nothing installed and no setting changed.

## The account that exists only for it

Most daemons in this series run as root. A few, like contactsd and usernoted, run as your user. Netbiosd runs as neither. It has its own reserved account:

```
$ dscl . -read /Users/_netbios RealName UniqueID
RealName: NetBIOS
UniqueID: 222
```

A dedicated service account for a name registrar is a quiet statement about trust. The daemon never needs your files, never needs your password, and never runs your code, so it gets an identity that can do exactly one system job and nothing else. Its current life on the measured Mac:

```
$ ps -Awwo pid,ppid,user,%cpu,rss,etime,time,comm | grep "[n]etbiosd"
55230     1 _netbios           0.0   2864    07:49:00   0:00.26 /usr/sbin/netbiosd
```

Parent process 1, which is launchd, so the daemon belongs to the system, not to any app that happens to be open. The memory footprint, 2,864 KB, is the smallest measured in this series so far, under contactsd's 3.3 MB. The processor column reads 0.0 percent at the moment of sampling, and the TIME column, total processor time for the whole life, is 0.26 seconds. Eight hours on shift, a quarter of one second of work.

The binary itself is 1,360,512 bytes at /usr/sbin/netbiosd, a universal slice carrying x86_64, arm64e and arm64e.x1, so the same file boots on Intel and Apple silicon. It was built and signed by Apple on 24 September 2026 with platform identifier 26. Inside are 2,373 strings, and they read like the protocol's vocabulary: workgroup lists, refresh timers, a global workgroups banner for debugging, and one line worth keeping for later, detected ownership conflict for a NetBIOS name between the machines at two addresses.

## The name it registers

NetBIOS names are short. The format allows fifteen characters, and when your Mac's local hostname does not fit, the system generates one that does. The configuration lives in the exact file the manual page names, /Library/Preferences/SystemConfiguration/com.apple.smb.server.plist, described in the man page as the primary configuration for the SMB stack, updated by various system services and not to be edited by hand. Read it and you get the daemon's actual assignment:

```
$ plutil -p /Library/Preferences/SystemConfiguration/com.apple.smb.server.plist
{
  "DOSCodePage" => "437"
  "NetBIOSName" => "MACBOOKPRO-034F"
}
```

The measured Mac's local hostname is 20 characters, too long for the format, so the NetBIOS name became MACBOOKPRO-034F: fourteen characters, uppercase, the way the protocol has always wanted its names. The code page line is the detail that dates the whole exercise. Code page 437 is the original character set of the IBM PC in 1981, and your Mac keeps a setting for it, because a NetBIOS name registered on a network with genuinely old machines on it must be spelled in a character set those machines can render.

The third key in that file is the server description, which carries your Mac's friendly name, the one with the apostrophe in it that shows in the Finder sidebar. The registrar files all of it together: a modern Mac, announcing itself in a format written for machines that predate the Mac itself.

## Two ports, held open on every interface

The firewall question has a concrete answer, and it is in the launch dictionary. /System/Library/LaunchDaemons/com.apple.netbiosd.plist does not tell netbiosd to go listen somewhere. It declares the sockets and has launchd open them, then hands them over:

```
"Sockets" => {
    "NetbiosDatagramServices" => {
        "SockFamily" => "IPv4"
        "SockNodeName" => "0.0.0.0"
        "SockPassive" => true
        "SockProtocol" => "UDP"
        "SockServiceName" => "netbios-dgm"
        "SockType" => "dgram"
    }
    "NetbiosNameServices" => {
        "SockFamily" => "IPv4"
        "SockNodeName" => "0.0.0.0"
        "SockPassive" => true
        "SockProtocol" => "UDP"
        "SockServiceName" => "netbios-ns"
        "SockType" => "dgram"
    }
}
```

The service names resolve to the protocol's two standard ports, UDP 137 for the name service and UDP 138 for datagrams, and 0.0.0.0 with SockPassive means listening, on every interface, for anyone. You can see the result without touching the daemon:

```
$ netstat -an -p udp | grep -E '\.137|\.138'
udp4       0      0  *.137                  *.*
udp4       0      0  *.138                  *.*
```

That is what the application firewall means when it asks whether netbiosd may accept incoming network connections. The daemon is not misbehaving. It was built to hold two name service ports open on all interfaces, because that is what registering and defending a name on a NetBIOS network requires: other machines challenge your claim to a name by sending to port 137, and a registrar that cannot receive the challenge cannot defend anything.

If you are asked, both buttons are honest. Deny, and your Mac stops answering name service challenges, which nothing on a modern network will notice. Allow, and two UDP sockets that have been open since boot stay open.

One more fact from the same dictionary, and it explains the persistence people see in this daemon. The plist wires a keepalive through the reachability system, watched against the default route, target 0.0.0.0. In plain terms: as long as your Mac has any working path to the internet, the system considers netbiosd's job live.

## Fifty nine lives

The reachability trigger has a visible consequence, and it is the one that sends people searching. launchctl print system/com.apple.netbiosd on the measured Mac reported:

```
state = running
runs = 59
pid = 55230
immediate reason = xpc event
last exit code = 0
minimum runtime = 10
exit timeout = 5
nice = 20
```

Fifty nine runs in twenty seven days is about two lives a day, and the last exit code of zero means the previous life ended cleanly. This is not a crash loop. It is a daemon whose aliveness is tied to the shape of the network, restarted by the system whenever that shape changes: joining Wi-Fi, roaming between access points, a VPN tunnel arriving or leaving, a sleep and wake.

The unified log shows the handovers happening. Across one day on the measured Mac, three different netbiosd process ids appear, each starting with the same three lines, reading network settings, starting a path evaluator, attempting to bind. And on several of the handovers, the new life logs this:

```
unable to open broadcast UDP socket on <private>, port 137: Address already in use
unable to open broadcast UDP socket on <private>, port 138: Address already in use
```

It looks like a failure and it is spelled like one, but the sequence is a handover artefact. The outgoing life still holds the broadcast sockets when the incoming one tries to claim them, the bind is refused, and the daemon retries until the old sockets are released. Twenty four log lines in twenty four hours was the daemon's entire output on the Mac measured here, and every one of them was either a startup or a handover line. No errors about names, no conflicts, nothing defended, because nothing on this network challenges anyone.

The plist also makes two promises about the daemon's place in line. Nice 20 and LowPriorityIO true put it behind everything else for both the processor and the disk, and EnablePressuredExit is false, which puts netbiosd in the small club of daemons, with fseventsd and apsd, that the system has promised not to reclaim under memory pressure. A quarter second of CPU a day, and the system still signs a contract to keep it alive.

## The work nobody sees, and the one that shows

What is all this defending for, on a network where nothing speaks NetBIOS? The manual page answers honestly: netbiosd also browses and scavenges names from the network and makes them available through mDNSResponder. The old protocol's findings are translated into the modern one. If some router, NAS, or ancient printer on your network still broadcasts a workgroup, this is the daemon that hears it, and the Finder's Network view that can show Windows machines is downstream of that hearing.

The strings in the binary describe the rest of the job in plain text. A refresh timer for the workgroup list, with the interval configurable through the man page's `--max-refresh` and `--min-refresh` options. A stash of registered names. A debug mode, toggleable with SIGUSR1, and a packet pretty printer behind `--dump-packets`, which is as close as Apple gets to admitting this protocol is fun to watch. And the line that explains the only scenario where netbiosd genuinely earns a busy CPU column: an ownership conflict, two machines at two addresses both defending the same NetBIOS name, each answering the other's challenges, forever, or until someone renames a computer.

That is the honest playbook for a hot netbiosd. Look for two machines with the same name, which on small networks usually means two Macs restored from the same backup, or a VM cloned from its parent. Then look at the network itself, because a flapping interface multiplies handovers, and each handover is a small burst of settings reads, path evaluation and bind attempts. The daemon is 1.36 MB of code with no update machinery, no database and no media pipeline inside it. There is not much in there to burn.

One search absence is worth naming, because it separates this daemon from its noisier siblings: there are no netbiosd keychain prompts. Nobody's Mac asks them for a password because of this process. The prompt it does generate, the firewall one, belongs to two open sockets, and sockets do not need secrets.

## Read it yourself

Every fact above came off a stock Mac. The identity and the cost:

```
ps -Awwo pid,ppid,user,%cpu,rss,etime,time,comm | grep "[n]etbiosd"
log show --predicate 'process == "netbiosd"' --last 24h
```

The schedule, the sockets and the promise:

```
plutil -p /System/Library/LaunchDaemons/com.apple.netbiosd.plist
launchctl print system/com.apple.netbiosd
netstat -an -p udp | grep -E '\.137|\.138'
```

The name your Mac registered, and the one description of the whole job:

```
plutil -p /Library/Preferences/SystemConfiguration/com.apple.smb.server.plist
man netbiosd
```

Run the last command first. It is a manual page from 2009 that documents a protocol from 1987, running today on a machine that can run circles around everything the protocol was designed to connect, and it still describes the job in four lines that match everything above.

## FAQ

### What is netbiosd on Mac?

It is the daemon that speaks the NetBIOS protocol on behalf of your Mac, and its manual page says so in one line: netbiosd registers and defends one or more NetBIOS names, depending on the set of configured services, and it browses and scavenges names from the NetBIOS network, making them available to the system through mDNSResponder. NetBIOS is the naming system that personal computers used to find each other before DNS was everywhere, and macOS still ships its registrar. The binary sits at /usr/sbin/netbiosd, runs as its own reserved system account called _netbios, and it runs whether or not you have ever turned on File Sharing. On the Mac measured here it held 2.8 MB of memory and had burned a quarter of one second of processor time over eight hours of life, which is about as close to free as a process gets.

### Why does the firewall ask about netbiosd?

Because netbiosd listens on the network, on every interface, on two UDP ports. Its launch dictionary does not describe networking in the abstract: it hands the daemon two passive sockets, one for the NetBIOS name service on UDP port 137 and one for the NetBIOS datagram service on UDP port 138, both bound to 0.0.0.0, which means all of them. A process holding sockets open on every interface is precisely what the macOS application firewall means by accepting incoming network connections, so if you have the firewall enabled you may be asked whether netbiosd may do that. Either answer is safe on a network where nothing speaks NetBIOS anymore, which is nearly every network in 2026. Denying it costs you old style Windows workgroup browsing. Allowing it costs you nothing except two open UDP sockets that were already open.

### Why does netbiosd keep restarting, and can it use high CPU?

The restarting is by design, and the CPU is almost always somewhere else. launchctl on the Mac measured here showed 59 runs over 27 days, about two lives a day, with the current life started for an xpc event and every recorded exit clean. The property list keeps the daemon alive through a reachability trigger on the default route, so a Wi-Fi hop, a VPN coming up, a sleep and wake, anything that reshapes the network can end one life and begin the next. The unified log shows the seams: on this Mac, three separate netbiosd process ids appeared in a single day, each new one logging unable to open broadcast UDP socket, port 137, address already in use, because the previous life's sockets had not been released yet. That line looks like an error and reads like one, but it is a handover, not a fault. Actual sustained CPU is rare in a daemon whose total charge was a quarter second in eight hours. When it does happen, the binary's own strings name the honest cause: an ownership conflict, two machines defending the same NetBIOS name, or a network that keeps flapping and restarting the churn.

### Can I quit or disable netbiosd?

You can end one life of it and nothing more. It is a system LaunchDaemon, /System/Library/LaunchDaemons/com.apple.netbiosd.plist, inside the sealed system volume, with no switch for it anywhere in System Settings. Force quitting it in Activity Monitor gives you the same result the system gets on every network change: launchd starts a new one, minimum runtime ten seconds, and the counter ticks from 59 to 60. There is no user account password in the way because it already runs as the reserved _netbios account, not as you and not as root. The honest arithmetic is that the daemon costs 2.8 MB of memory and runs at nice 20 with low priority IO, deliberately last in every queue on the machine. There is nothing to win here, and 59 clean exits say the system agrees.
