How to Blur Background on Zoom, Teams & iPhone (2026)

Updated October 2026: new Zoom and Teams menu paths, Teams Standard vs Portrait blur explained, Zoom on iPad steps, and Google Meet’s cloud processing on low-core PCs.

Why this matters

If you just want a tidy background on your next call, the first section answers that in under a minute, for every app you are likely to use. If you build software — a product manager, founder, or engineer adding video to an app — the rest of the article explains the technology well enough that you can scope the feature, talk to your engineers about it, and avoid the traps that make a demo look broken. Background blur is one of the most-used camera features in video calling, in most apps it runs entirely on the user's own device, and it is a clean introduction to the real-time AI that powers everything from virtual backgrounds to live captions. Understanding it once means understanding a whole family of features.

The fast answer: blur your background right now

Here is where the control lives in each app, checked against each vendor's help pages in October 2026. In Zoom, Teams, FaceTime and Continuity Camera the blur happens on your own device, which matters for both speed and privacy. Google Meet is the one exception: on a computer with fewer than 8 logical CPU cores, or in a virtual desktop, Meet may process the effect in Google's cloud instead (Google Meet Help, 2026).

Zoom (desktop). To blur your background on Zoom, open the Zoom Workplace app, click your profile picture, then Settings. Choose Video & effects, open Virtual backgrounds, and click Blur. Mid-call, click the small ^ arrow next to Video, choose Video & effect settings, and click Blur. Blur is free on every Zoom plan. It needs an up-to-date app (Zoom enforces a global minimum version) and the same hardware as a virtual background without a green screen: on Windows roughly a Core i5 (3rd gen+) or Ryzen 5, on a Mac an Apple M-series chip or a 5th-gen Core i5 or newer (Zoom Support, 2026).

Zoom in a browser. Zoom's web app supports virtual backgrounds only in Chrome, Edge or on ChromeOS, on a processor with at least 4 logical cores. If the Blur option does not appear in the browser, join from the desktop app instead.

Zoom (phone or tablet). In a meeting, tap More, then Settings, then Virtual background, and tap Blur. It applies instantly. The iPad steps are the same as on iPhone; the full iPad walkthrough, and what to do when the option is missing, is in the next section.

Microsoft Teams. On the pre-join screen, select Effects and avatars, click the dropdown arrow next to Blur, and choose Standard blur or Portrait blur. Already in the meeting? Select More actions, then Video effects and settings, then Video effects, pick the blur, Preview it and click Apply (Microsoft Support, 2026). On Windows, Ctrl+Shift+P toggles blur during a call. Background effects are not available in the Linux desktop client or in optimized VDI.

iPhone and iPad (FaceTime and any video app). During a FaceTime call, tap your own video tile, then tap Portrait. To turn it on for any video app — Zoom, Teams, Webex, a browser — open Control Center, tap Video Effects, and turn on Portrait; it stays on across apps until you switch it off. This works on iPhone and iPad models with Apple's A12 Bionic chip or newer (that means iPhone XS and later), running a current version of iOS or iPadOS.

Mac, and iPhone as a Mac webcam (Continuity Camera). On macOS Sonoma or later, during any video call, click the green Video menu in the menu bar and choose Portrait; the arrow next to it opens a slider that sets how strong the blur is. On macOS Ventura the same switch sits in Control Center under Video Effects. Native Portrait on the built-in camera needs an Apple silicon Mac laptop, but Continuity Camera with an iPhone XR or later (iOS 16+) brings the same blur to any Mac that runs macOS Ventura, Intel Macs included (Apple Support, 2026).

Google Meet. Before joining, click Blur at the bottom right of your self view. In a call, click Video settings next to the microphone and choose Blur background; Backgrounds and effects offers Slightly blur and full Blur. On a computer Meet needs Chrome or Edge 114+, Firefox 110+, or Safari 16.4+ on a Mac, with graphics acceleration turned on (Google Meet Help, 2026).

Figure 1. Where the blur toggle lives in each app, and what each one needs to run, as of October 2026. Save this; it is the whole how-to on one screen.

That is the whole how-to. The rest of this article explains what actually happens when you tap that button — and how to build the same thing yourself.

How to blur your background on Zoom on an iPad or iPhone

Short answer: join the meeting in the Zoom Workplace app, tap More, then Settings, then Virtual background, and tap Blur. Outside a meeting, tap your profile picture, then Settings, Video & effects, Background & effects, and tap Blur on the Backgrounds tab (Zoom Workplace for iOS 6.5.0 or later).

Zoom offers blur on an iPhone 8 or later, an iPad 5th or 6th generation (9.7-inch), any iPad 7th generation or newer (10.2-inch) and every iPad Pro, according to Zoom's 2026 virtual background requirements. Your administrator must also allow virtual backgrounds. If the Blur tile is missing, it is almost always one of three things: the app is older than Zoom's global minimum version, the device is older than that list, or your company turned virtual backgrounds off. On an iPhone XS or later and recent iPads (A12 chip or newer) there is a fallback that works in any app: open Control Center, tap Video Effects and turn on Portrait. Zoom then receives an already-blurred camera feed from iOS.

Standard blur vs Portrait blur in Teams: what is the difference?

Short answer: Standard blur in Microsoft Teams blurs the whole room strongly, so most details behind you are hard to make out; Portrait blur is lighter and adds a sense of depth, keeping you in focus while the room stays softly recognizable. Pick Standard blur when you want to hide more of the room and Portrait blur for a polished, camera-like look.

Table 1. Microsoft Teams' two blur strengths. Teams remembers the last one you picked for your next meeting.

Both options work from the same flat webcam image, using the segmentation explained below; neither measures distance the way an iPhone's Portrait effect does. Microsoft's own help page adds a warning worth repeating: blurring or replacing your background may not hide sensitive information from other people in the meeting.

What "blurring the background" really means

It sounds like the app is smudging part of the picture, and visually that is the result. But the hard part is not the blur. The hard part is the question that comes first: which pixels are the background, and which pixels are you?

Picture your video frame as a grid of tiny colored squares — the brightness-and-color dots called pixels that make up every digital image. To blur only the background, the software has to label every single one of those squares as either person or not person, on every frame, thirty times a second. That labeling job is called segmentation — splitting the image into meaningful regions. The specific kind used here is person segmentation: separate the human from everything else.

The output of segmentation is a second, simpler image the same size as your video, called a mask (engineers also call it a matte). In the mask, every pixel that belongs to you is marked white, and every pixel that belongs to the room is marked black. Think of it as a stencil cut out in the exact shape of your body and hair. Once the software has that stencil, the rest is easy: keep the original sharp pixels wherever the stencil is white, and paint blurred pixels wherever it is black.

So background blur is really two steps wearing one button: first find the person (the AI step), then blur everything else (the easy step). A green screen does the same job with a colored cloth and a lot of studio lights. Background blur throws away the cloth and asks a neural network to find your outline instead.

Figure 2. Background blur in three stages: capture the frame, segment the person into a mask, then blur only the masked-out background and composite you back on top.

How the app finds you: the segmentation model

The "find the person" step is done by a small neural network — a piece of software trained on hundreds of thousands of labeled photos until it learned the visual pattern of "human in front of a camera." You do not program the rules ("arms are cylindrical, hair is fuzzy"); you show the network enough examples and it learns the rules itself.

The most widely used model for this in browsers and apps is Google's MediaPipe Selfie Segmentation. It is deliberately tiny. The model has roughly 106,000 internal numbers (engineers call them parameters) and the whole file is about 454 kilobytes — smaller than a single photo. It is built on a compact image-recognition design called MobileNetV3, chosen because it was made to run fast on phones rather than on data-center hardware. The model shrinks your video frame down to a small square — 256 pixels by 256 pixels — does its work there, and scales the resulting mask back up. A smaller input means less math, and less math means it finishes in time.

Why 256 by 256 and not the full frame? Because the mask does not need to be razor-sharp to look good once it is blurred — the blur itself hides small errors at the edge. Running on a shrunk-down frame is the trade that makes real-time blur possible on a phone.

The 33-millisecond rule that governs everything

Here is the constraint that shapes every design decision in this feature. Video plays at about 30 frames per second — 30 still images shown in quick succession, the way a flipbook makes drawings move. If you do the division out loud:

1 second ÷ 30 frames = 0.0333 seconds per frame
0.0333 seconds × 1000 = 33.3 milliseconds per frame

So a new frame arrives roughly every 33 milliseconds (a millisecond is one-thousandth of a second). Both steps — find the person, then blur the background — have to finish inside that window. If the work takes longer than 33 milliseconds, the app cannot keep up: it either drops frames, making your video stutter, or it falls behind, making you look laggy.

This is why the chip doing the work matters so much. The same MediaPipe model finishes a frame in under 3 milliseconds when it runs on a GPU — the graphics processing unit, the chip originally built to draw game graphics, which does thousands of small calculations at the same time. Run a segmentation model on a general-purpose CPU without heavy optimization and it can take several times the entire frame budget. Google Meet makes the CPU path work only by combining a low-resolution model with XNNPACK, a library that uses the processor's vector instructions, and on computers with fewer than 8 logical cores Meet now prefers cloud processing instead. Same feature, same picture; which chip does the arithmetic, and how, decides whether it keeps up. That gap is the whole reason these features feel smooth on a modern device and choppy on an old one.

A worked example makes the budget concrete. Suppose your segmentation step takes 4 milliseconds and your blur step takes 6 milliseconds:

4 ms (segment) + 6 ms (blur) = 10 ms total
33 ms budget − 10 ms used = 23 ms to spare  → smooth

Now suppose the same work runs on a weak CPU and segmentation alone takes 95 milliseconds:

95 ms (segment) > 33 ms budget  → about 10 of every 30 frames get processed; two in three are dropped

The math is unforgiving, and it is the same math whether you are using Zoom or building your own app. To learn how this fits into the broader timing of a live call, see our sub-100ms real-time latency budget breakdown.

Two ways to know what is "background": flat vs. depth

Now the interesting part — and the reason your iPhone's blurred background usually looks better than your laptop's. There are two fundamentally different ways to decide what counts as background, and the major apps split between them.

The first way is segmentation only, working from a single flat image. The model looks at colors, shapes, and edges and guesses where you end and the room begins. It has no idea how far away anything is; it only knows "this looks like a person, that looks like a wall." Zoom, Microsoft Teams, and Google Meet all work this way, because they have to run on any ordinary webcam, which captures a flat picture with no distance information.

The second way adds depth. Your iPhone's Portrait effect does not just recognize your shape — it works out roughly how far away each part of the scene is, then blurs things by distance, the way a real camera lens does. Apple starts from a person-segmentation matte computed on its Neural Engine — a chip inside the phone dedicated to AI math — and adds depth: measured where the camera can provide it (the TrueDepth front camera on Face ID iPhones, or two rear lenses that see the scene from slightly different viewpoints, the way your two eyes do) and estimated from the image where it cannot, as on an Apple silicon Mac's single webcam. The result is a blur that gets gradually stronger as the background recedes.

That gradual falloff is why Portrait blur looks "cinematic." A real lens does not blur the background uniformly; objects just behind you are slightly soft, and the far wall is very soft. Photographers call the size of each out-of-focus point the circle of confusion — the farther a point is from the focus plane, the bigger and softer its blurred disc. Depth-based blur reproduces that. Flat segmentation blur cannot: with no distance data, it blurs the entire background by the same fixed amount, which is why it can look like a sticker of you pasted on frosted glass.

Table 2. The two engineering approaches to background blur, and why iPhone Portrait usually looks more natural than webcam blur.

What each app actually does under the hood

The apps differ in interesting ways once you look past the button.

Google Meet is the most openly documented because it runs inside a web browser, where nothing is hidden. Google's engineers run the segmentation model on the CPU — not the GPU — on purpose, using a library called XNNPACK that squeezes maximum speed out of the processor through WebAssembly (a way to run near-native-speed code in a browser). They chose the CPU for the widest device coverage and lowest battery drain. Since then Meet has added a second path: on computers with fewer than 8 logical cores and in virtual desktops it automatically favors cloud-based processing, and some Workspace editions can run blur in the cloud on purpose (Google Meet Help, 2026). The model produces a low-resolution mask, refines its edges to line up with the real image, and then hands the blur itself to the GPU through WebGL2 (a browser graphics interface). Their blur shader deliberately imitates a lens: it varies the blur strength pixel by pixel in proportion to the mask, and weights pixels so the sharp foreground does not "bleed" a halo into the soft background.

Apple leans entirely on dedicated hardware. The Neural Engine produces a high-quality person matte frame by frame, fast enough for a live call. Because the work runs on a chip purpose-built for it rather than on a general GPU shader, it drains less battery — which is why Portrait blur barely dents an iPhone's runtime. Apple has been building this matte technology since 2019, when it first exposed segmentation mattes that could separate not just a person but their hair, skin, and teeth.

Zoom and Microsoft Teams ship their own native segmentation models tuned for desktops and phones. The clearest engineering fingerprint they leave is their hardware lists: Zoom publishes a processor table per platform (on Android, for example, an 8-core arm64 chip, 3 GB of RAM and a Snapdragon 835-class GPU or newer), and Teams turns background effects off entirely in its Linux desktop client and in optimized VDI. That is exactly why background blur silently fails to appear on some older or virtualized machines: the chip cannot do the math inside the frame budget, so the feature hides itself rather than stutter.

Common pitfall: the "is my background being uploaded?" worry — and its opposite. Zoom, Teams, FaceTime and Continuity Camera blur on your own device; your raw camera frames are not sent to a server to be processed. Google Meet can switch to cloud processing on low-core PCs and virtual desktops, so check that if your policy forbids it. On-device processing is good for privacy. But it creates a trap for builders: blur is cosmetic, not secure. The unblurred frame still exists in memory on the device, and a poorly built app can leak a sharp frame for a split second when the camera turns on before the model loads. If your product blurs for privacy reasons — telemedicine, legal, HR — you must hold the first frames back until the mask is ready, not assume the blur is instant.

Build it into your own product

If you are adding background blur to your own web-based video product, the browser now gives you every piece you need, and the architecture mirrors the three stages from Figure 2. We cover the model choice in depth in our MediaPipe Selfie Segmentation with WebGPU lesson; here is the shape of the whole pipeline.

You tap into the camera stream at the raw-frame point — the place in the pipeline where each frame is still an uncompressed image with real pixels. The browser exposes this through two objects: MediaStreamTrackProcessor, which hands you each incoming camera frame, and MediaStreamTrackGenerator, which lets you push your modified frame back into the call. Between them sits your transform: run the frame through a segmentation model to get the mask, then composite a blurred copy with the sharp original using the mask as the stencil.

One portability catch: the W3C standard version of this API runs only inside a Web Worker and names the output object VideoTrackGenerator; that is the version Safari implements and Mozilla has committed to for Firefox. Chrome still ships its earlier main-thread MediaStreamTrackGenerator, shown below (Mozilla WebRTC blog, 2024). Production code feature-detects both and moves the transform into a worker where the standard version exists.

// Pull each camera frame, segment, blur the background, push it back.
const processor = new MediaStreamTrackProcessor({ track: cameraTrack });
const generator = new MediaStreamTrackGenerator({ kind: "video" });

const transformer = new TransformStream({
  async transform(frame, controller) {
    const mask = await segmenter.segment(frame);   // person vs. background
    const output = composite(frame, blur(frame), mask); // sharp you, soft room
    controller.enqueue(output);
    frame.close();                                  // release memory every frame
  },
});

processor.readable.pipeThrough(transformer).pipeTo(generator.writable);
const blurredStream = new MediaStream([generator]);  // send this into the call

For the segmentation model, Google's MediaPipe Image Segmenter ships a ready-to-use JavaScript build with the Selfie Segmentation model family that Google Meet's background features grew out of. For the blur-and-composite step, do it on the GPU: either WebGL2, as Google Meet does, or the newer WebGPU. In October 2026 WebGPU ships in Chrome and Edge on Windows, macOS and ChromeOS (Chrome 121+ on Android 12+, Chrome 144+ on Linux with Intel Gen12+ graphics), in Firefox 141+ on Windows and Firefox 145+ on Apple silicon Macs running macOS Tahoe (147+ on earlier macOS), and in Safari 26 on macOS, iOS and iPadOS; Firefox on Linux, Android and Intel Macs is still Nightly-only (gpuweb implementation status, 2026), so keep WebGL2 as the fallback. Doing the blur on the CPU is the single most common reason a homemade version stutters.

Three mistakes wreck most first attempts. Edge halos: the mask is never pixel-perfect at hair and glasses, so a hard cutoff leaves a glowing fringe — feather the mask edge by a few pixels so the transition is gradual. Temporal flicker: because the model runs fresh on every frame, the mask edge wobbles frame to frame and the outline shimmers — blend each mask slightly with the previous one to steady it. Memory leaks: each VideoFrame holds real memory and must be explicitly closed every frame, or the tab crashes within minutes. Get those three right and a browser-based blur is production-grade. If blur is one feature of a larger calling product rather than the product itself, our video conferencing software development team builds it into the call pipeline together with recording, screen sharing and the SFU, and tests it on the oldest devices you have to support.

Figure 3. The browser pipeline for building your own blur: camera in, segment, blur on the GPU, composite, stream out — with the three mistakes that break it flagged at the points where they happen.

Where the blur sits in the bigger picture

Background blur is the gentlest member of a large family of real-time camera-AI features that all share its two-step shape: understand the frame, then change it. Virtual backgrounds use the same mask but paint an image where the blur would go. Beauty filters and gaze correction reshape the foreground instead of the background. Live captions run a different model on the audio rather than the video. Every one of them lives at the same raw-frame point in the pipeline and answers to the same 33-millisecond clock. Learn the blur and you have learned the pattern. The video SDK you build on decides whether you can reach that raw-frame point at all — a choice we unpack in our WebRTC AI APIs and video SDK comparison.

There is also a regulatory edge worth knowing. Because blur relies on detecting a person, it is technically a face-and-body detector, and where it shades into recognition — identifying who the person is — European rules begin to apply. Blur itself does not identify anyone, so it stays clear, but teams adding more analysis on top should read our note on face detection under the EU AI Act before they ship.

Frequently asked questions

How do I blur my background during a video call the way Zoom does?

Open the app's video effects and choose Blur: in Zoom, Settings, then Video & effects, then Virtual backgrounds, then Blur; in Teams, Effects and avatars, then Blur; in Google Meet, the Blur button under your self view. On an iPhone or iPad, Control Center, then Video Effects, then Portrait blurs your camera for every app at once.

How do I blur my background on Zoom on an iPad?

In the meeting tap More, then Settings, then Virtual background, then Blur. It works on an iPad 5th generation or newer and every iPad Pro; if Blur is missing, update the app or ask your admin to enable virtual backgrounds.

Can I blur my Zoom background in a browser?

Zoom's web app supports virtual backgrounds only in Chrome, Edge or ChromeOS on a processor with 4 or more logical cores. If you do not see Blur in the browser, use the Zoom desktop app, where blur is available on every plan.

What is Portrait blur in Teams?

Portrait blur is the lighter of Teams' two blur options: it keeps you sharp and softens the room with a sense of depth, like a camera with shallow focus. Standard blur is the stronger one that hides most details of the room.

How does background blur compare between iPhone models and iOS versions?

The Portrait toggle is the same on every iPhone with an A12 chip or newer (iPhone XS and XR onward) from iOS 15 on. Older iPhones do not get Portrait in calls, but app-level blur still works: Zoom supports blur from the iPhone 8.

How do blur techniques compare across video apps?

Zoom, Teams and Google Meet blur a flat image with a segmentation model, so the whole room gets the same softness; iPhone and Mac Portrait add depth or a lens-like falloff, which looks more natural at hair and glasses. Meet is the only one that may process the effect in the cloud, on PCs with fewer than 8 logical cores.

Does background blur upload my video to a server?

Not in Zoom, Teams, FaceTime or Continuity Camera, which blur on your device. Google Meet may use cloud processing on low-core computers and virtual desktops. Either way, blur is cosmetic: other participants may still make out details.

How do I add background blur to my own web video call?

Read raw frames with MediaStreamTrackProcessor, segment each frame with the MediaPipe Image Segmenter, blur and composite on the GPU with WebGPU or WebGL2, and push the result back with a track generator. Close every VideoFrame and feather the mask edge.

Where Fora Soft fits in

We have built real-time video products since 2005 — video conferencing, WebRTC apps, e-learning, telemedicine, and live surveillance — and on-device camera effects like background blur are among the most-requested features our clients ask for. The work is rarely the blur itself; it is making the blur hold steady across a thousand different cameras, phones, and lighting conditions without draining the battery or leaking a sharp frame at the wrong moment. In telemedicine especially, where a blurred background protects a patient's home, the difference between a cosmetic blur and a privacy-grade one is an engineering decision made early. We help teams pick the model, the chip, and the pipeline that fit the product, so the feature that looks simple in a demo still works on a five-year-old phone in a poorly lit room. Effects like blur are part of our real-time video processing and effects work, and on phones our on-device AI mobile app development team runs the segmentation model on the neural engine of the device.

The book

AI for Video: A Complete Guide to Intelligence in Video Products: From Real-Time Pipelines and Agents to Serving, Cost, Compliance, and Verticals

Background blur is the easiest way onto the real-time map: a raw frame in, a model, a changed frame out, all of it inside 33 milliseconds. Volume 7 of the handbook walks that map in full — where AI plugs into a WebRTC pipeline, what each insertion point costs in latency and in dollars per stream-hour, and how live captions, translation and on-the-fly moderation are built on the same clock you met here. Written by Nikolay Sapunov, CEO at Fora Soft.

Read it on Amazon →Kindle & paperback · Fora Soft Video Engineering Handbook

See our case studies

References

1. W3C, "MediaStreamTrack Insertable Media Processing using Streams" (Working Draft) — the raw-frame insertion point (MediaStreamTrackProcessor / MediaStreamTrackGenerator) that exposes each camera frame as a VideoFrame for on-device processing. https://www.w3.org/TR/mediacapture-transform/
2. W3C, "Media Capture and Streams" (Recommendation) — getUserMedia and the MediaStreamTrack model that camera-effect pipelines build on. https://www.w3.org/TR/mediacapture-streams/
3. W3C, "WebGPU" (Working Draft, GPU for the Web WG) — modern browser GPU compute and graphics; the fast path for the blur-and-composite step. https://www.w3.org/TR/webgpu/
4. W3C, "WebCodecs" (Working Draft) — low-level frame encode/decode access that pairs with the raw-frame API. https://www.w3.org/TR/webcodecs/
5. W3C, "WebRTC: Real-Time Communication in Browsers" (Recommendation, 13 March 2025) — the live-call platform the blurred stream is sent over. https://www.w3.org/TR/webrtc/
6. Google Research, "Background Features in Google Meet, Powered by Web ML" (2020) — first-party account: MediaPipe + XNNPACK CPU inference, WebGL2 rendering, and a circle-of-confusion blur shader that weights pixels to prevent foreground bleed. https://research.google/blog/background-features-in-google-meet-powered-by-web-ml/
7. Google Research, "High-Definition Segmentation in Google Meet" (2022) — the higher-resolution successor model and edge-refinement approach. https://research.google/blog/high-definition-segmentation-in-google-meet/
8. Google for Developers, "MediaPipe Selfie Segmentation" / "Image Segmenter" docs — MobileNetV3-based model, 256×256 and 144×256 variants, ~106K parameters, ~454 KB; web build with sub-3 ms GPU-delegate inference. https://ai.google.dev/edge/mediapipe/solutions/vision/image_segmenter/web_js
9. Apple Developer, WWDC19 Session 260, "Introducing Photo Segmentation Mattes" — on-device person, hair, skin, and teeth mattes from AVCapture and Core Image; the matte technology behind Portrait effects. https://developer.apple.com/videos/play/wwdc2019/260/
10. Apple Support, "Change FaceTime video settings on iPhone" — how to enable Portrait mode in FaceTime and via Control Center Video Effects; A12 Bionic (iPhone XS) or later, iOS 15+. https://support.apple.com/guide/iphone/change-the-video-settings-iphfb3d2a12b/ios
11. Apple Support, "Use your iPhone as a webcam for Mac" (Continuity Camera) — Portrait via Mac Control Center Video Effects; requirements: iPhone XR or later on iOS 16+, any Mac with macOS Ventura or later. https://support.apple.com/en-us/102546
12. Microsoft Support, "Change your background in Microsoft Teams meetings" — Effects and avatars → Blur (Standard / Portrait), in-meeting Video effects; not available on Linux or in optimized VDI; privacy caveat (checked October 2026). https://support.microsoft.com/en-us/teams/meetings/change-your-background-in-microsoft-teams-meetings
13. Zoom Support, "Blur your background" — Settings → Video & effects → Virtual backgrounds → Blur, in-meeting and mobile steps; iOS 6.5.0+ for changing the background outside a meeting (checked October 2026). https://support.zoom.com/hc/en/article?id=zm_kb&sysparm_article=KB0060387
14. Zoom Support, "Virtual background system requirements" (KB0060007) — processor lists for Windows, macOS, Linux; Android and iOS device lists (iPhone 8+, iPad 5th gen+, iPad Pro); web app: Chrome/Edge/ChromeOS, 4+ logical cores; blur uses the same requirements. https://support.zoom.com/hc/en/article?id=zm_kb&sysparm_article=KB0060007
15. Google Meet Help, "Change background & apply visual effects" — Blur and Slightly blur; browser minimums; cloud-based processing on CPUs with fewer than 8 logical cores and in VDI (checked October 2026). https://support.google.com/meet/answer/10058482
16. Apple Support, "Use video effects and mic modes on Mac" — Portrait from the Video menu on macOS Sonoma or later with a strength slider; Apple silicon laptop or Continuity Camera with iPhone XR or later. https://support.apple.com/en-us/105117
17. web.dev, "WebGPU is now supported in major browsers" (25 November 2025) — Chrome/Edge, Firefox 141 (Windows) and 145 (macOS Tahoe on Apple silicon), Safari 26. https://web.dev/blog/webgpu-supported-major-browsers
18. Mozilla WebRTC blog, "Unbundling MediaStreamTrackProcessor and VideoTrackGenerator" (20 September 2024) — worker-only standard API vs Chrome's main-thread MediaStreamTrackGenerator. https://blog.mozilla.org/webrtc/unbundling-mediastreamtrackprocessor-and-videotrackgenerator/
19. Office 365 for IT Pros, "Teams Background Blur Evolves" (24 November 2023) — Standard blur (2018) vs Portrait blur in the new Teams client. https://office365itpros.com/2023/11/24/teams-background-blur/
20. GPU for the Web, "WebGPU Implementation Status" (wiki) — per-browser, per-platform shipping status; Firefox 141 (Windows), 145/147 (Apple silicon macOS), Linux and Android still Nightly; Chrome 144+ on Linux Intel Gen12+ (checked October 2026). https://github.com/gpuweb/gpuweb/wiki/Implementation-Status