The app is real, open source, and already distributed through Microsoft’s Sysinternals Homebrew tap. Microsoft’s ZoomIt documentation now links directly to the Mac project, while the official Microsoft Developer channel has published Russinovich’s walkthrough of the project. ZoomIt for Mac requires macOS 14 Sonoma or later and brings the familiar presentation-focused combination of magnification, live screen annotation, screenshots, screen recording, panorama capture, a break timer, and webcam picture-in-picture to Apple’s platform.
Windows Latest described the result as a mostly working, “90-plus percent” port with bugs. Russinovich’s own public account is more specific — and somewhat different. He said he used GitHub Copilot with GPT-5.5 and Opus 4.8, and characterized the completed weekend result as fully featured. The distinction is worth making: the early implementation may have been around 90 percent complete when he expressed surprise at its progress, but the released project has continued moving after that initial sprint. The Microsoft-owned GitHub repository now has more than 100 commits, open issues, and active pull requests.
The practical news for Mac users is straightforward: ZoomIt is no longer confined to Windows. The more consequential news for Windows developers and IT teams is that Russinovich did not ask an AI to invent a product from a blank prompt. He gave it a mature, tightly defined application with decades of behavior, feature decisions, and source code behind it — then directed it through an unfamiliar platform.
A Windows utility with a very specific job
ZoomIt has remained useful for more than two decades because it solves a problem that neither a screenshot tool nor a slide deck handles well: showing a live desktop to an audience while controlling attention precisely.
Russinovich originally wrote ZoomIt for Windows Internals training. The tool can freeze and magnify the screen, let a presenter draw arrows, boxes, lines, and text over the active display, then return directly to the application being demonstrated. That makes it especially handy for live troubleshooting, software training, product demonstrations, and technical presentations where moving between a PowerPoint deck and an application can break the flow.
Microsoft’s current ZoomIt page lists version 12.22 for Windows, published on September 10, 2026, and continues to describe it as a tool Russinovich uses in his own presentations. The Windows version remains a tray-based utility and supports the familiar Ctrl+1 zoom mode and Ctrl+2 draw-without-zoom mode, along with screen capture and recording features.
The Mac project does more than reproduce a basic magnifier. Its published feature list includes static and live zoom, click-through interaction in live zoom mode, freehand and shape annotations, text annotations, clipboard snips, OCR-based text capture, screen recording with optional system audio and microphone input, webcam overlay, post-recording editing, and scrolling panorama screenshots.
That breadth is why the project makes a better test of AI-assisted development than a small command-line tool. It had to accommodate global shortcuts, display capture, composition of live overlays, media recording, Apple privacy controls, app signing, and a menu-bar-first interface. Those are platform behaviors, not merely code syntax differences between Windows and macOS.
The important advantage was not AI alone
Russinovich told Microsoft Developer that he began with the original ZoomIt source as a reference and built the Mac version incrementally through prompts. That is the part routinely lost in the simplified version of this story.
He knew exactly what ZoomIt was supposed to do, which features mattered, which interaction patterns users expected, and where the output did not match the product’s behavior. AI could generate candidate implementations and help bridge unfamiliar APIs, but Russinovich supplied the specification — including the accumulated edge cases encoded in a tool he has maintained for years.
That is a fundamentally different job from asking an AI coding agent to create “a screen recording tool for macOS.” An open-ended request leaves the model to decide requirements, architecture, user experience, test cases, and security boundaries. ZoomIt for Mac began with a known product model, an established set of shortcuts and workflows, and a developer capable of recognizing a wrong answer immediately.
Russinovich’s own model disclosure also corrects a vaguer claim in the original report. The work was not completed by an unspecified AI service. He said GitHub Copilot was the working environment, using GPT-5.5 and Opus 4.8. That does not make the result a benchmark for either model in isolation: the outcome reflects the models, Copilot’s agentic workflow, the original application code, and a highly experienced engineer driving the effort.
For development teams, the useful lesson is narrower and more credible than “AI can now port any legacy application in a weekend.” AI is particularly well positioned when a team has a working codebase, a clear behavioral reference, good test coverage or reproducible scenarios, and an engineer who can constrain the work in small steps.
The less documented the application, the more ambiguous its business rules, and the more serious its consequences if it fails, the less likely this kind of compressed timeline will transfer cleanly.
macOS permissions expose where a port becomes product work
The official ZoomIt for Mac repository shows that the final work involved more than generating functional features. Its documentation devotes substantial attention to macOS privacy permissions, distribution variants, application identity, signing, and the practical failure modes users can encounter when testing builds.
ZoomIt needs Screen Recording permission to provide its core capture-based functions. Microphone and Camera permissions are optional, but required when a user enables audio recording or a webcam overlay. The repository notes that screen capture consent is controlled by macOS privacy protections, while microphone and camera use also depend on appropriate application entitlements under Apple’s hardened runtime.
For administrators and power users, this changes the installation experience. ZoomIt runs as a menu-bar application rather than a conventional Dock app, and its first screen capture action prompts the user to grant Screen Recording access in macOS Privacy & Security settings. The user must then relaunch the same application instance.
There is also a particularly technical edge case for people building ZoomIt locally. macOS associates privacy approval with both an app’s bundle identifier and its code-signing identity. Microsoft’s project uses a separate com.sysinternals.zoomitmac.dev identifier for local developer builds and reserves com.sysinternals.zoomitmac for the officially signed application. That prevents a self-built copy and the production app from fighting over the same privacy entry.
This is exactly the sort of deployment detail that can disappear in an AI-generated prototype and matter immediately in a real release. The repository even documents how to reset stale Screen Recording permission records when macOS continues to reject capture access after a user installs a properly signed build.
In other words, AI helped produce a credible implementation quickly, but the shipping path still depends on conventional engineering: a distinct application identity, Developer ID signing, notarization, permissions, testing, release packaging, and support documentation.
The Mac App Store version will not be identical
One practical caveat is already visible in Microsoft’s own build documentation: ZoomIt’s Homebrew and Mac App Store variants do not expose the same feature set.
The standard Homebrew build is unsandboxed and includes DemoType, the feature that lets a presenter inject prepared text during a demonstration. The repository says a sandboxed Mac App Store version compiles DemoType out. The limitation appears to arise from the distribution model and Apple’s sandboxing restrictions, rather than a missing implementation.
That means Mac users should not assume that every installation channel will offer identical behavior. It also illustrates a broader point about cross-platform work: functional parity is only one kind of parity. Store rules, application sandboxing, privacy prompts, packaging, and code-signing requirements can change what actually reaches users even when the underlying source tree has the feature.
The project’s build documentation also says release bundles are Universal by default, supporting both Apple Silicon and Intel Macs. Users installing the official app through the Sysinternals Homebrew tap should not need to compile it themselves. Developers who do want to inspect or modify it have an MIT-licensed Microsoft repository, including a Swift package, build scripts, tests, and detailed guidance for local development.
What Windows developers should take from the experiment
The headline number — two days — should not become an excuse for managers to treat platform ports as a solved cost problem. Russinovich’s result is impressive precisely because he had advantages that most migration projects lack: deep ownership of the original program, a small and focused product scope, a longstanding feature set, access to the code, and no need to preserve a complex enterprise integration surface.
ZoomIt is also a desktop utility, not a line-of-business system tied to Active Directory, regulated data, proprietary drivers, multiple cloud services, third-party SDK commitments, and years of customer-specific workflow changes. A team moving a large Win32 application to macOS, Linux, or a web platform still needs a migration plan, performance validation, security review, accessibility work, packaging, telemetry, support readiness, and regression testing.
But the project does demonstrate a genuine shift in the economics of exploratory work. Previously, a senior Windows developer who wanted to evaluate a Mac port might need to spend weeks acquiring platform fluency before seeing whether the project was viable. With an agentic coding tool able to explain frameworks, draft integrations, and produce working prototypes from a concrete behavioral reference, the first serious evaluation can happen much faster.
That does not eliminate review. It moves the human bottleneck from typing code toward deciding requirements, inspecting implementation choices, reproducing failures, and determining whether the result is safe enough to ship.
ZoomIt for Mac is now a useful real-world artifact of that transition rather than a conference-stage demo. It gives presenters on macOS a long-requested Sysinternals tool, while giving Windows developers a public codebase that shows where AI accelerated the work — and where the remaining engineering still had to be done.