MacCam

A virtual camera for your Mac that touches up your picture live: smoother skin, a brighter look, a slimmer face, bigger eyes, lipstick and blush, plus 27 filters. It sits in the menu bar and shows up as a camera called MacCam in Zoom, Google Meet and other apps. The effects come from GPUPixel, and faces are found with Apple's Vision framework.

There's no download yet: you build MacCam from source. A plain build does everything except the virtual camera. The virtual camera needs a paid Apple Developer account, because macOS only installs camera extensions from apps signed with one.

Features

• Beauty effects: smooth skin, brighten, slim face, bigger eyes, lipstick and blush, each with its own strength. More settings control sharpening, how far skin smoothing reaches and how much skin detail to keep.
• Filters: 27 looks in five groups, each with sliders for its settings. They go on top of the beauty effects.
  • Color: brightness, contrast, exposure, saturation, hue, RGB, white balance, grayscale, invert, luminance range.
  • Blur: Gaussian, box, bilateral, iOS-style.
  • Stylize: posterize, pixellate, halftone, crosshatch, emboss, sketch, toon, smooth toon.
  • Distort: glass sphere, sphere refraction.
  • Edges: Sobel, Canny, directional Sobel.
• Framing: choose which part of the picture to send. The camera runs at its largest 30 fps format (1920×1080 on most webcams) and the area is cut out at that resolution, so zooming in up to 1.5× still sends full detail at 1280×720.
• Face tracking: the effects follow your face as you move. Show Face Points draws the points they use on the video.
• Menu bar and settings window: the menu has the effects, a slider for each, the filters and a camera picker. The settings window has the same controls plus a live preview, the framing editor and the virtual camera's status. Settings are kept between launches.
• Camera only when needed: the real camera, and its green light, only runs while you can see the settings window or an app is showing the MacCam camera.

Build and run

Needs macOS 14 or later, an Apple Silicon Mac, Xcode, XcodeGen and CMake (brew install xcodegen cmake).

scripts/build.sh --run

A camera icon appears in the menu bar and the settings window opens. Allow camera access when macOS asks. To also use MacCam in Zoom or Meet, see the next section.

The first build downloads GPUPixel v1.3.1's source into ThirdParty/ and builds it (about 15 seconds). It's built rather than downloaded because MacCam patches it (scripts/gpupixel-desktop-shaders.patch): many of GPUPixel's filters only have OpenGL ES shaders, which macOS's desktop OpenGL rejects, and its Gaussian blur has a desktop-shader bug.

project.yml is the source of truth for the Xcode project. To work in Xcode, run xcodegen generate and open MacCam.xcodeproj. Changes made in Xcode's project editor are lost the next time the project is generated.

The app's version is set in one place, Config/Version.xcconfig, and CHANGELOG.md lists what changed in each version.

Turn on the virtual camera (Zoom, Meet)

The virtual camera is a camera extension, which is a kind of system extension. macOS only installs one from an app whose signature carries the com.apple.developer.system-extension.install entitlement, and that entitlement needs a provisioning profile. The steps:

1. Use a paid Apple Developer team; Personal Teams can't use System Extensions. Sign in to it in Xcode → Settings → Accounts.

2. Create Config/Signing.local.xcconfig with your team ID (Apple Developer website → Account → Membership details) and a bundle ID of your own. Git ignores this file, so neither ends up in the repository.

   MACCAM_SIGNED = YES
   MACCAM_TEAM = ABCDE12345
   MACCAM_BUNDLE_ID = com.yourcompany.maccam
   

3. Run scripts/build.sh --install --run. Xcode registers the bundle ID, and the same ID plus .CameraExtension, as app IDs on your team and creates the profiles. The script copies the app to /Applications, which is the only place macOS installs extensions from, then launches it.

4. When macOS asks, allow it in System Settings → General → Login Items & Extensions → Camera Extensions.

5. In Zoom or Meet, pick MacCam as the camera. The app switches the real camera on while a call is showing MacCam, and off when it stops.

Apps that were already running when the virtual camera was installed or updated don't see it until you quit and reopen them. That includes MacCam itself, which restarts itself for this. scripts/build.sh only updates the camera extension when its code changes, so rebuilding the app alone doesn't interrupt a call.

Self-test without a camera

build/MacCam.app/Contents/MacOS/MacCam --selftest ThirdParty/GPUPixel/demo.png build/selftest

This runs every effect at full strength on GPUPixel's sample portrait. It prints the number of face landmarks found and the time per frame. It then runs every filter and prints how much each one changed the picture. It writes before.png, after.png, face-points.png, a contact sheet of all filters (filters.png) and the virtual camera's placeholder frames to build/selftest.

How it works

camera ─AVCapture─▶ MacCam.app ─GPUPixel─▶ frame ─CoreMediaIO sink stream─▶ camera extension ─▶ Zoom / Meet
                                          └─▶ settings preview

Face points come from Apple's Vision framework, which runs on the Neural Engine. They're converted to the 111-point layout GPUPixel's face filters use (App/GPUPixel/VisionFaceLandmarks.h) and smoothed between frames (App/GPUPixel/FaceTracker.h).

• App/: the menu bar app.
  • StatusMenuController: the AppKit menu with its slider rows.
  • SettingsWindow: the SwiftUI settings window.
  • VideoPipeline: capture, effects and output.
  • GPUPixel/MCBeautyProcessor: the Objective-C++ wrapper around GPUPixel.
  • GPUPixel/GPUPixelFilters.swift: the filters MacCam offers and their settings.
  • GPUPixel/FaceTracker.h: face tracking with Vision.
  • VirtualCameraSink: pushes frames into the extension.
  • ExtensionInstaller: installs and removes the extension.
• CameraExtension/: the CoreMediaIO camera extension.
  • Passes the app's frames on to the apps using the camera.
  • Shows a placeholder frame when the app isn't sending anything.
  • Tells the app whether anyone is watching.
• Shared/: constants and the placeholder renderer.

Troubleshooting

• Unsigned builds are ad-hoc signed, so macOS may ask for camera access again after each rebuild. To reset it: tccutil reset Camera com.example.maccam, with your own bundle ID if you set one.
• Extension status: systemextensionsctl list
• Logs: /usr/bin/log stream --predicate 'subsystem BEGINSWITH "com.example.maccam"', again with your own bundle ID if you set one (plain log is a zsh builtin)

License

MacCam is licensed under the PolyForm Noncommercial License 1.0.0. You can use, change and share it for any noncommercial purpose, such as personal use, research, teaching or use by a charity, but not for commercial purposes.

GPUPixel, which the build downloads and patches, has its own license, the Apache License 2.0.