Capptivo: an MIT-licensed screen recorder for demo videos on macOS, Windows and Linux

The problem Capptivo targets, and who it is for

Recording a demo video usually means two jobs: capturing the screen, then spending far longer editing it so the viewer's eye lands where it should. Capptivo bundles both. The README describes it as a free, open-source alternative to Screen Studio and Cursorful, and the author states plainly that it is not a clone: it is a tool built for personal use and then released under the MIT license. That framing matters, because the feature set reads like one person's editing workflow rather than a committee's roadmap.

The intended user is someone who records software walkthroughs, changelogs, or onboarding clips and wants the zoom-and-caption polish without a monthly fee. The README contrasts this with paying $29/month for video editing software. Capptivo is a desktop application, not a web service, and it is not aimed at long-form video production, multi-track editing, or anything involving a timeline of separate clips.

Native capture pipelines per operating system

The architecture is the most interesting part. Capptivo is a Tauri app: a Rust backend in src-tauri/ and a React plus Vite frontend, with PixiJS handling rendering and Zustand holding state. The repository root contains separate HTML entry points for each window the app opens (recorder.html, editor.html, annotation.html, area.html, camera.html, frame.html), which tells you the recorder, the annotation overlay and the editor are distinct webviews rather than one monolithic UI.

Capture does not go through a portable abstraction. On macOS the README says it uses ScreenCaptureKit with VideoToolbox hardware H.264 encoding, and pulls system audio from a companion SCK stream. On Windows it uses Windows.Graphics.Capture, probes hardware encoders per machine (NVENC, QuickSync, AMF, Media Foundation), and takes system audio through WASAPI loopback. On Linux it goes through xdg-desktop-portal and PipeWire, with the screen or window chosen in the system dialog and system audio coming from the PulseAudio or PipeWire monitor.

The output is a fragmented MP4, which the README describes as crash-safe. Alongside the video, the recorder writes a cursor.json file holding a 60 Hz cursor and click track. That file is the input to the auto-zoom features: click-based zooms and follow-cursor zoom are computed from recorded events, not detected by analysing pixels after the fact. It is a sensible design, and it explains why the cursor probe exists separately on each platform.

Installing Capptivo and recording a first clip

There is no package manager route. The README points to the GitHub Releases page, where installers are published per platform: aarch64 or x86_64 .dmg and .app.tar.gz for macOS, .msi or a setup .exe for Windows, and .deb, .AppImage or .rpm for Linux.

macOS builds are unsigned. The README instructs users to right-click the app and choose Open on first launch, or to allow Capptivo under System Settings, Privacy & Security. Screen Recording permission is requested on first launch, and the app needs a relaunch afterwards. The global hotkey to open the recorder is Option+Shift+R on macOS and Alt+Shift+R on Windows and Linux. There is also a tray icon.

Captions are the one feature with an external dependency. The README states that captions need a system whisper.cpp whisper-cli binary, and that the app downloads the model weights on first use. That is worth reading twice: the binary is not bundled, so a machine without whisper-cli installed will record fine but will not caption.

If you want to build from source rather than use an installer, the quick start is two commands. Rust, Node and pnpm are prerequisites, and FFmpeg is fetched automatically as a per-platform sidecar by scripts/fetch-ffmpeg.mjs on first dev or build.

pnpm install
pnpm tauri dev

The sidecar binaries are installed as capptivo-ffmpeg and capptivo-ffprobe rather than ffmpeg and ffprobe, which the README explains is deliberate so that Linux packages do not collide with the system ffmpeg package. The package.json also exposes pnpm test, which runs a typecheck followed by scripts/run-selfchecks.mjs, and pnpm check:cursor-hotspots.

Where Capptivo stops being the right tool

Linux is the weakest platform, and the README is unusually direct about it. Area selection is not available yet on Linux; the workaround is to record and then crop in the editor. Cursor replay and follow-zoom on Wayland depend on PipeWire cursor Metadata, and only when the portal supports it. If the portal does not, the cursor is embedded in the recording and zoom-follow is unavailable. That is a hard functional split between Wayland sessions, not a rough edge.

Linux also requires PipeWire 1.0 or newer, which the README places at roughly Ubuntu 24.04 and later. Older distributions are out of scope.

The macOS signing situation is the second constraint. Unsigned builds mean every user goes through the right-click, Open dance, and any organisation with a policy against unsigned binaries will not be able to deploy it at all. The README documents the Tauri signing secrets a maintainer would add (APPLE_CERTIFICATE, APPLE_SIGNING_IDENTITY, TAURI_SIGNING_* and others) but they are not in place for the published releases.

Finally, the project describes itself as built around one person's needs. Features outside that workflow should be assumed absent rather than merely undocumented. The README does not describe a scripting interface, a CLI for batch recording, or any headless mode.

How it differs from OBS Studio and Screen Studio

The obvious free alternative is OBS Studio, and the difference is not capture quality but what happens after capture. OBS is a live production tool: scenes, sources, streaming, a plugin ecosystem. Capptivo records a single take and then edits it with the same cursor and click data that was captured alongside the video. If you need to composite a webcam, a capture card and a browser source in real time, OBS is the tool and Capptivo has nothing to offer.

Against Screen Studio, the commercial product the README names, the split is licensing and delivery rather than capability. Screen Studio ships signed, notarised builds and a support relationship. Capptivo ships MIT-licensed source you can modify, and unsigned binaries you may have to talk your security team into. The README's own framing is that Capptivo is not a clone, so feature parity should not be assumed in either direction.

Maintenance, releases and what the MIT license covers

The repository is not archived, and the last push was on 2026-08-24. Releases are frequent and small: v1.0.1 and v1.0.2 landed on 2026-08-02, and v1.0.3 on 2026-08-05. Version numbers are kept in sync across three files (package.json, src-tauri/tauri.conf.json and src-tauri/Cargo.toml), and the README warns that they must stay identical.

Upgrade cost for users is low because the app is distributed as installers rather than through an auto-update channel the README describes. You re-download from Releases. For maintainers, the cost is in the release workflow: GitHub Actions builds macOS Intel and Apple Silicon, Windows and Linux, and opens a draft GitHub Release with the installers attached. The README notes that a workflow failure reading Resource not accessible by integration is fixed by setting Settings, Actions, General, Workflow permissions to Read and write. There is also a workflow_dispatch trigger, so releases can be cut without pushing a tag.

The license is MIT, which permits use, modification and redistribution, including in proprietary projects. The repository also carries a THIRD_PARTY_NOTICES.md at the root, which is where the bundled dependencies' terms are recorded. MIT covers Capptivo's own code; it does not relicense FFmpeg, whisper.cpp or the model weights the app downloads, and those carry their own terms. That is a factual boundary, not legal advice.

Editorial conclusion

Capptivo fits people who record product demos regularly and want auto zooms and captions without a subscription. It does not fit anyone who needs signed installers, Linux area selection, or a stable API for scripting. Before adopting it, check the GitHub Releases page for your platform's installer, confirm your Linux session exposes the PipeWire cursor Metadata, and decide whether the unsigned macOS build is acceptable for your team.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. SECHAK-AG/capptivo on GitHub