ScrollSnap: stitched scrolling screenshots with a draggable capture region on macOS

ScrollSnap exists for the long page that will not fit in one screen

Capturing a long article, a chat log or a spreadsheet that runs past the bottom of the display usually means taking several screenshots and stitching them later. ScrollSnap is a macOS application that does the stitching as part of the capture, so the output is a single image assembled from consecutive frames of the same region.

The target user is a person working on a Mac who needs that long image, not a developer building capture infrastructure. The project describes itself as an open source macOS application for capturing scrolling screenshots with a customizable selection area and menu interface, and it ships nine languages: English, Simplified Chinese, French, German, Japanese, Korean, Romanian, Spanish and Turkish.

Two distribution routes are offered. One is the App Store listing, which supports App Store managed installation and updates. The other is a ZIP from GitHub Releases described as the free compiled binary, where future updates need a manual download. So the project gives you a choice between automatic updates and a build you control yourself, without either route being a paid tier.

The application is written in Swift and sits on AppKit and ScreenCaptureKit, and the interface is an overlay that floats above your work rather than a separate window you switch to.

A draggable overlay defines the region before anything is captured

The visible workflow starts with an overlay. Launching ScrollSnap displays an overlay with a selection rectangle and a menu bar, and the rectangle is the thing that defines what gets captured. You drag it to move it and use resize handles to change its size, so the region can be sized to a browser column, a terminal pane or an image preview.

The overlay is summoned from anywhere through a global shortcut, `Control + Option + S`, which the Settings window can change, disable or reset. Dismissing the overlay does not quit the application. It keeps running in the background, so the next capture is one shortcut away. Escape or the close button dismisses the overlay while leaving ScrollSnap running, and quitting is a separate action through `Cmd + Q` or the Options menu.

Behind the overlay sits a small state machine in `OverlayManager`, which creates overlays on all screens. `OverlayView` coordinates that overlay and hands drawing and interaction off to two child views: `SelectionRectangleView` for the region and `MenuBarView` for the commands beside it.

The menu itself is draggable and holds the options to capture, save, reset positions or cancel. Resetting positions is a separate action from the one in Settings, which suggests the author expects people to move the menu around and want it back.

StitchingManager compares overlapping frames to join them

The actual pixel work is split across two files. `ScreenshotUtilities` uses ScreenCaptureKit to capture the defined rectangle and, according to the project description, does so while excluding the application's own UI, which is the part that would otherwise appear in every frame and corrupt the stitching.

`StitchingManager` then combines the captured images into a single result, and the project's description gives the mechanism as overlap detection. The consequence for the user is that the region you select must contain the content you want to keep scrolling through, since the algorithm infers where one frame ends and the next begins from shared pixels.

A draggable thumbnail appears after capture, and `ThumbnailView` handles that preview with drag-and-drop and swipe gestures. You can drag the image elsewhere, swipe right to save it, or right-click for options such as Show in Finder, Delete and Close. The capture itself is started by clicking Capture and stopped by clicking Save, or by pressing Return while the overlay has focus.

Save destinations are configurable from the Options menu, and the documented list covers Desktop, Documents, Downloads, Clipboard, and opening the result in Preview. Writing straight to the clipboard is the shortest path for pasting the stitched result into a document or a chat.

Building from source means managing a local signing identity

If you want the code rather than the app, the installation path is a clone and an Xcode build.

git clone https://github.com/brkgng/ScrollSnap.git
cd ScrollSnap

After that, open `ScrollSnap.xcodeproj` in Xcode and press `Cmd + R` to build and run. There is no package manager step and no command line installer in the project, so the build environment is Xcode itself. The README asks that the app have screen recording permissions enabled in System Settings > Security & Privacy, since ScreenCaptureKit capture requires that consent.

Contributors working locally need one extra setup step, and the project explains why it matters. Copy `Config/Signing.local.xcconfig.example` to `Config/Signing.local.xcconfig`, then set your local `DEVELOPMENT_TEAM` in that file, and you uncomment `CODE_SIGN_IDENTITY = Apple Development` only if Xcode cannot infer it on your machine.

The stated reason is that macOS tracks Screen Recording permission by signed app identity. An ad-hoc signed build can look like a new app after every code change, which produces repeated permission prompts. A stable local development signature keeps that permission in place across rebuilds. That is a concrete trap for anyone evaluating the project as a fork.

Where ScrollSnap stops: single platform, no automation, no capture history

Several limits are visible from the repository layout and the documentation rather than from the code.

The first is platform. The repository is a Swift project with a SwiftUI app entry point, AppKit views and a ScreenCaptureKit based capture path, and the documentation describes macOS only. There is no Windows or Linux build and no browser extension counterpart in the tree.

The second is that there is no headless or scripted mode. Every step in the documented workflow involves the overlay, the menu or the thumbnail, and the trigger is a global shortcut rather than a command line argument. If your requirement is to capture a hundred pages on a schedule, the project offers nothing for that.

The third is that the captured region is chosen by hand each time. The application remembers nothing about a region except that the selection and menu positions can be reset from Settings, and the settings window exposes language, position reset and the global shortcut. There is no list of saved regions, no preset widths, and no documented export format.

The fourth is release cadence and packaging. The project publishes GitHub releases, with 3.1.0 on 2026-08-02, 3.0.0 on 2026-06-12 and 2.4.0 on 2026-04-29, but the ZIP route means updates are a manual step for anyone who chose it over the App Store.

ScrollSnap next to the macOS screenshot tool and a manual stitch

The built-in alternative is what macOS already offers. A user can press the platform screenshot shortcut and capture a region, but the result stops at one frame, so a long page still means repeated manual captures and an external editor to join them. ScrollSnap's difference is entirely in the joining step, plus the global shortcut and the overlay that keeps the capture flow in one gesture sequence.

The other comparison is with a general-purpose image tool. Assembling two PNGs side by side or vertically in any editor produces a stitched result too, and it produces one that is exactly as long as the frames you shot. The gap is that the manual route gives you a file that is a picture of the page, while a stitched capture from ScreenCaptureKit captures successive frames of the same region as the content moves, which is the only way to record a page that scrolls while keeping a single continuous strip.

There is also the choice of not installing anything. ScreenCaptureKit is a framework that a developer can call directly, and doing so means writing the capture loop and the overlap handling yourself, but it also means no App Store account, no permission dance for end users and no dependency on a third party binary on a machine that handles untrusted input. ScrollSnap is the packaged version of that work, and the MIT licence lets you read the code and take the pieces.

A solo-maintained Swift project with a permissive licence

The repository is not archived and the last push was on 2026-10-20, so the code is being worked on. The author describes the project as solo maintained and says community contributions, particularly translations, are welcome. Recent GitHub releases include 3.1.0 from 2026-08-02, so the release line is moving rather than sitting still.

The licence is MIT, which covers reuse of the source in other projects and the redistribution of modifications. For a screenshot utility, that matters mostly in the negative sense: there is no copyleft obligation that would force a company to open-source its own tooling.

What the MIT licence does not cover is the App Store distribution. Installing from the store means Apple's terms and sandboxing apply, and the app still asks for screen recording permission, which is the one capability the whole product depends on. A reviewer considering a fork should look at the Xcode project settings, the ScreenCaptureKit call sites in `ScreenshotUtilities`, and the `StitchingManager` overlap logic, since those three places hold the behaviour that makes the app work and the parts most likely to break on a future macOS release.

Editorial conclusion

ScrollSnap fits a macOS user who regularly needs one long image from a scrolling page and is comfortable granting screen recording permission, and it fits contributors who want a compact SwiftUI and AppKit codebase to read. It does not fit a team that needs a managed deployment, because the App Store and the manually downloaded ZIP are the only distribution routes and there is no self-hosted or CLI path. Before adopting it, confirm that your macOS version exposes ScreenCaptureKit to the build you install, and check the permission prompt behaviour, since macOS ties screen recording consent to the signed app identity.

Frequently asked questions

Official sources

1. Brkgng/ScrollSnap on GitHub
2. Issues
3. License: MIT
4. README
5. Releases