Background Blur

The soft, melted background behind a portrait subject is one of photography's oldest signals of quality — and one that a webcam is physically incapable of producing. Modern background blur fakes it with a neural network and a lot of GPU arithmetic, and the difference between a convincing fake and a distracting one comes down to details most implementations get subtly wrong.

Real blur is optics

In a real lens, background blur — bokeh, from the Japanese for haze or blur — is a side effect of geometry. A lens can only focus at one distance; everything nearer or farther renders each point of light as a disc rather than a point, and the discs grow with distance from the focal plane. How fast they grow is governed by depth of field: a large aperture and a physically large sensor produce a shallow depth of field, where a face is sharp and the bookshelf a metre behind it dissolves. That's why portrait photographers prize fast lenses on full-frame cameras.

A webcam sits at the opposite extreme of every variable. Its sensor is tiny, its lens is small and slow, and it's engineered for the deepest possible depth of field — sensibly, since a fixed-focus camera must keep you sharp whether you're at 40 cm or 80. The optical consequence is unavoidable: essentially everything in frame is in focus, always. No setting, no accessory, no firmware can conjure shallow depth of field from that geometry. If a webcam image is going to have a blurred background, the blur must be computed.

The computational turn

Smartphones hit the same wall first, and their answer defined the genre. Apple's Portrait mode, introduced with the iPhone 7 Plus in 2016, used its dual cameras to estimate depth and blur the image accordingly; Google's Pixel phones followed with machine learning doing more of the work, leaning on learned person segmentation alongside depth cues. The insight that generalized was that for pictures of people, you don't strictly need depth at all — you need to know which pixels are the person. That reframing turned an optics problem into a computer-vision problem, and it's what made background blur feasible on a single fixed webcam with no depth hardware: person segmentation, a neural network trained to label every pixel as subject or background, producing a mask — an image-sized map of confidence that each pixel belongs to a person. Blur the background pixels, keep the person pixels, composite, and repeat for every frame, fast enough for video.

A taxonomy of artifacts

Everyone has seen this go wrong on calls, and the failures are systematic enough to name.

• Halos — a fringe of misclassified pixels around hair and other fine structure, where wisps are too thin for the mask to resolve, so a band of sharp background survives around your head or a strip of your hair gets blurred away.
• Edge flicker — the mask is recomputed every frame, and its uncertain pixels flip allegiance frame to frame, making the boundary shimmer as you move. Temporal smoothing tames it at the cost of the mask lagging behind fast motion.
• Ghosting — the subject smearing outward into the blurred background, as if radiating a faint aura of themselves.

Ghosting deserves the closer look, because unlike the others it isn't a segmentation error — it's a compositing error, and it happens with a perfect mask. A blur is a weighted average over a neighborhood of pixels. Blur the whole frame naively and then composite, and every blurred background pixel near the boundary has averaged in some of its neighbors — including foreground pixels, because the blur kernel reaches across the mask edge and pulls the subject's colors into the background. Skin tones and shirt colors bleed outward into the blurred region, and the composite shows the subject wearing a smeared copy of itself. The correct fix is structural: exclude foreground pixels from the background blur entirely, averaging only the background pixels that fall under the kernel, and renormalize the weights so the result isn't darkened near the edge. Done that way, the background near your shoulder is built purely from background.

Confidence and the edge

The mask itself needs judgment, because a segmentation network doesn't emit yes-or-no answers — it emits confidence, and the interesting values live at the boundary. Treat low-confidence pixels as foreground and background detail clings sharply around your outline; treat them as background and your ears and hair start dissolving into blur. Composite them half-and-half and the edge turns into a soft translucent band that reads as neither. Practical pipelines therefore shape the mask in stages: smooth it first, suppressing the per-frame noise that causes flicker, then harden the edge — steepen the transition from background to foreground so the subject's silhouette stays crisp against the softened backdrop. A real lens, after all, doesn't render you as translucent at the edges; the plausible fake keeps the boundary decisive while everything beyond it melts.

Blur on a live call

Video calls add the unforgiving constraints: this must run at video rate, on every frame, for an hour, without monopolizing the machine — which is why call-quality segmentation runs as compact models on the GPU or neural engine rather than the heavyweight networks used for offline photo editing. Where the blur runs matters too. Blur applied inside one meeting app exists only there; blur applied upstream, in the camera pipeline itself, follows you into every app because the apps simply receive a camera whose picture already has the treatment. And it's worth saying plainly: on a call, background blur is less about vanity than about signal. A sharp background full of shelves, doors and motion competes with your face for attention; softening it directs the viewer's eye the same way a portrait lens does — which is why the effect became one of photography's conventions in the first place. There's a privacy dividend as well: the whiteboard, the laundry, the family member crossing the hall all melt into an unreadable wash, so the room stops being part of the broadcast.

In DeskBroadcast

DeskBroadcast takes the upstream approach. It segments the person with Apple's Vision framework, at video rate and entirely on-device, and applies the blur live on the GPU ahead of the virtual camera — so Zoom, Meet and Teams all receive the finished image from one pipeline. The blur itself is person-excluded and normalized: foreground pixels are excluded from the background blur, so the subject never smears into its own halo — the classic ghosting artifact — and the kernel weights are renormalized so edges stay clean rather than darkened. The segmentation mask is smoothed to keep the boundary stable frame to frame, then hardened at the edges so your silhouette stays crisp against the softened background. The result is visible in the menu-bar panel's live preview while you adjust it, it composes with the Look pipeline's grading in the same GPU chain, and it's included in the free tier.