ZoomitForMac: Sysinternals ZoomIt for macOS, Installed via Homebrew

What ZoomitForMac solves, and who it is for

Sysinternals ZoomIt built its reputation on Windows as a presentation aid: freeze the screen, magnify a region, draw on it, then get out of the way. ZoomitForMac ports that idea to macOS as a menu-bar utility. The README lists the feature set directly: static zoom over a frozen ScreenCaptureKit display capture, live zoom of the running screen, draw-without-zoom annotation at 1x, pen, line, rectangle, ellipse, arrow, highlighter, undo and erase, blank-screen sketch pads, typing annotations, viewport and region snips, OCR snip, a break timer, MP4 recording with a post-recording editor, webcam picture-in-picture, and scrolling panorama capture.

The audience is narrower than "everyone who presents on a Mac". This is for people who already know the ZoomIt keyboard model and want it on macOS, or who want the annotation and snip workflow bundled into one utility rather than assembled from separate screenshot and drawing apps. The README targets macOS 14 or newer, so the floor is recent. It is a developer-friendly repository: the top level holds Package.swift, Sources/, Scripts/, and a ZoomItInfo.plist, and the build instructions are SwiftPM commands.

How the zoom, draw and capture pipeline is put together

The architecture splits into capture, overlay and output. Static zoom works over a frozen ScreenCaptureKit display capture: the screen stops updating and you magnify a still image. Live zoom instead magnifies the running screen, and the README notes click-through interaction when you are not drawing, so the app is not a modal wall between you and the desktop.

Drawing is layered on top of whichever mode is active. Static zoom and drawing overlays are captured even when ScreenCaptureKit omits ZoomIt's own windows, according to the README. Live zoom is deliberately excluded from its own capture to avoid feedback, which is the right call and also means a recording of a live-zoomed screen will not contain the zoom effect itself. Webcam picture-in-picture is described as staying fixed in the recorded viewport and being composited into overlay recordings rather than zoomed into the source image, so the camera frame does not scale when you zoom.

Recording uses ScreenCaptureKit and AVAssetWriter. When recording stops, the built-in editor opens before the save panel, so trimming, appending, fades, mute and export happen before the file is written. OCR is a separate path: it uses Apple's on-device Vision text recognition, runs entirely on-device, and needs no extra permissions. Panorama capture records a selected scroll region while you scroll, filters repeated frames, handles vertical or horizontal scrolls, suppresses fixed headers and footers, shows stitch progress, and can be canceled with Esc.

Installing ZoomitForMac with Homebrew and your first snip

The README gives Homebrew as the install path, through the Sysinternals tap. The first command installs the cask from the tap explicitly:

brew install --cask microsoft/sysinternalstap/zoomit

If the tap is already configured, the shorter form also works:

brew install --cask zoomit

After install, the app runs from the menu bar. Grant Screen Recording permission when macOS asks, since capture depends on it. Microphone and Camera permissions are only needed if you record with those options. Then try the simplest workflow: press Control+6 and drag a rectangle. According to the README, that copies the selected screen region to the clipboard; holding Shift (Control+Shift+6) saves it to a PNG file instead. Snip also works while zoomed, capturing the magnified view. If you want the text rather than the pixels, press Control+Option+6, drag a rectangle, and the recognized text lands on the clipboard.

Uninstalling is the matching cask command:

brew uninstall --cask zoomit

For development, the README uses SwiftPM directly:

swift build
swift run ZoomItMacSelfTest
swift run ZoomIt

The self-test covers viewport math, annotation lifecycle and rendering, settings persistence, and panorama stitcher regressions. A sandbox product-surface variant is exercised by adding the App Store compiler condition:

swift run -Xswiftc -DZOOMIT_APP_STORE ZoomItMacSelfTest

Global hotkeys and the annotation keyboard model

ZoomIt's value is in muscle memory, and this port keeps the modifier-heavy scheme. The README's default table maps static zoom to Control+1, draw without zoom to Control+2, break timer to Control+3, live zoom to Control+4, record screen to Control+5, record region to Control+Shift+5, snip region to clipboard to Control+6, snip region to file to Control+Shift+6, OCR region to clipboard to Control+Option+6, panorama to clipboard to Control+8, and panorama to file to Control+Shift+8. All global hotkeys are configurable in Settings.

Inside a mode, the model is dense. While zoomed, Option+Up and Option+Down change zoom level, the mouse wheel zooms or resizes tools depending on mode, Command+S and Command+C save or copy the viewport, and Esc or right click exits the active overlay. Drawing starts on left click; holding Shift gives a line, Control a rectangle, Control+Shift an arrow, and Tab an ellipse. Color keys are R, G, B, O, Y, P, W and K for red, green, blue, orange, yellow, pink, white and black, with Shift plus a color selecting highlighter ink. T enters typing mode, Shift+T right-aligns it, Up and Down or the mouse wheel adjust font size, Command+Z undoes, and E erases.

That is a lot of chords to learn, and the README does not document a printable cheat sheet or an on-screen shortcut reference. If your team already uses Control+1 through Control+8 for something else, expect to spend time in the Settings dialog remapping before the tool feels invisible.

Distribution, sandboxing and the two build variants

One source tree produces two products. The README's table is explicit: the Homebrew variant is unsandboxed and includes DemoType, while the Mac App Store variant runs under App Sandbox and compiles DemoType out. The ZOOMIT_DISTRIBUTION variable selects the channel, and the README's text is truncated at its default value, so the exact default is not stated in the available material. If you depend on DemoType, that is a concrete reason the sandboxed build may not be what you want.

Testers should run the bundled app, not swift run. The README says launch at login requires running ZoomIt as an app bundle so macOS attributes the login item to ZoomIt instead of the host process used for development. The contributor build is named ZoomIt (Dev).app with bundle id com.sysinternals.zoomitmac.dev, deliberately distinct from an installed official ZoomIt.app in the Screen Recording list. That naming choice matters in practice: macOS keys Screen Recording grants to bundle identity, and two builds sharing an identity would fight over the same permission entry.

Building a release bundle and stamping a version looks like this:

zsh Scripts/build-app.sh release
ZOOMIT_VERSION=1.2.0 zsh Scripts/build-app.sh release
defaults read "$PWD/.build/ZoomIt (Dev).app/Contents/Info" CFBundleShortVersionString

Local bundles default to version 1.0. The README states that values must contain two or three numeric components, such as 1.2 or 1.2.0, and that malformed values fail before compilation or signing begins. The official Azure DevOps build supplies ZOOMIT_VERSION from the version entered when the pipeline is queued.

Where ZoomitForMac is the wrong tool

The macOS 14 floor is the first hard boundary. Anyone on macOS 13 or earlier cannot use it at all, and the README offers no fallback. The second is permissions: Screen Recording is required for capture, and macOS handles that grant at the system level. The README documents permission checks for Screen Recording, Microphone and Camera, but it does not document rollback or a recovery path if a grant goes stale, so a failed capture after an OS update is something you diagnose through System Settings rather than through the app.

Recording has a real gap. Live zoom remains excluded from ZoomIt's own capture to avoid feedback, so if your goal is a tutorial video that shows the magnification effect, this is not the mechanism that produces it. Static zoom and drawing overlays are captured, per the README, so the frozen-zoom path is the one that records. Webcam picture-in-picture is fixed in the recorded viewport rather than following the zoom, which is a deliberate compositing choice and also a constraint if you wanted the camera to track the magnified region.

Launch at login is another case where the development workflow diverges from the shipped one. Running from SwiftPM is supported for development, but the README states launch at login and production distribution are intended for the bundled app form. If you try to make swift run ZoomIt behave like an installed app, you are outside what the documentation describes. Finally, the README does not document rollback of a release or a downgrade procedure, so pinning to a known-good version is something you arrange through Homebrew rather than through anything the project describes.

How this differs from the Windows ZoomIt and from screen-recording apps

The obvious alternative is the original Sysinternals ZoomIt on Windows. The approaches are the same in spirit but not in implementation: the Windows tool is a Sysinternals utility with its own capture stack, while ZoomitForMac is a Swift application built on ScreenCaptureKit, AVAssetWriter and Apple's Vision framework for OCR. The README describes OCR as running entirely on-device with no extra permissions, which is a macOS-specific property that comes from using Vision rather than shipping a separate recognition engine. If your team is split across platforms, the hotkey model transfers, but the permission model, the sandboxed Mac App Store variant, and the bundle-identity handling do not.

Compared with a dedicated screen recorder, ZoomitForMac bundles recording into a presentation overlay rather than treating it as the primary job. The post-recording editor covers preview, trim, append, fades, playback controls, volume mute and slider, and export before save, which is enough for a clip you want to shorten before sharing. It is not a timeline editor, and the README does not describe multi-track editing or anything beyond appending clips. If recording is your main activity, a recorder built around recording will fit better; if annotation during a live demo is the main activity and recording is occasional, the integrated editor is the more convenient shape.

Licence, maintenance and what an upgrade costs you

The repository is MIT licensed, which permits commercial and private use, modification and redistribution provided the copyright notice and permission notice are included. That is a permissive licence, but it is not legal advice: if you redistribute a modified build, read the LICENSE file at the repository root and confirm the notice requirements with your own counsel. The README's build-variant table is the part with practical licensing consequences, since the Mac App Store variant is sandboxed and compiles DemoType out while the Homebrew variant is unsandboxed and includes it.

Maintenance signals are current. The repository is not archived, and the last push was on 2026-09-16. Releases listed are 12.3.0 on 2026-08-19, 12.21.0 on 2026-07-24, and 12.2.0 on 2026-07-22. Note the ordering: 12.21.0 predates 12.3.0 by a month, so the version numbers do not sort the way a reader might assume, and anyone pinning a version should pin the release tag rather than reasoning about numeric order.

Upgrade cost is mostly permission and identity churn. Settings persist immediately to UserDefaults, so preferences survive an upgrade. What changes between builds is bundle identity, and the README's separate ZoomIt (Dev).app bundle id exists precisely because Screen Recording grants are tied to it. If you move between a development bundle and an installed official ZoomIt.app, expect a fresh permission prompt. The self-test suite covers viewport math, annotation lifecycle and rendering, settings persistence, and panorama stitcher regressions, which gives you a way to check a build before shipping it to testers, though the README does not claim it covers recording or OCR.

Editorial conclusion

Adopt ZoomitForMac if you present, teach or demo on macOS 14 or newer and want ZoomIt's zoom-and-draw workflow without leaving the Mac, and accept Homebrew or a bundled build as the install path. Skip it if you need a Mac App Store install today, or if you present on Windows, where the original Sysinternals ZoomIt is the same family of tool. Before rolling it out, verify Screen Recording permission is granted, that the global hotkeys do not collide with your existing shortcuts, and that launch-at-login is configured from a bundled app rather than a swift run process.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. microsoft/ZoomitForMac on GitHub
4. README
5. Releases