Screenity

Screenity is a powerful open-source Chrome extension for recording your screen, camera, or audio with zero restrictions and zero data collection. Unlike cloud-dependent screen recording tools, Screenity processes everything locally on your device — no account required, no upload delays, and no watermarks. Users can record any tab, application window, desktop, or camera feed for as long as needed, making it the go-to choice for educators, developers, and remote teams who need fast, private recordings.

Beyond simple capture, Screenity includes a real-time annotation layer built on Fabric.js that lets users draw, add text, arrows, and shapes directly on the screen during recording. AI-powered background blur and replacement via MediaPipe, smooth zoom-in capabilities, cursor and click highlighting, and an alarm-based auto-stop system make Screenity a professional-grade tool that rivals commercial alternatives. Recordings export to MP4, GIF, or WebM, and can be saved directly to Google Drive for instant shareable links without third-party storage overhead.

The built-in editor supports trimming, cropping, audio removal, and clip assembly — all running in the browser via FFmpeg WebAssembly — so users never need to leave the extension to finalize their content. For teams needing more, Screenity Pro extends the experience with EU-hosted cloud storage, multi-scene editing, zoom keyframes, auto-captions, and link sharing, while the core extension remains fully featured and completely free.

As a Chrome Manifest V3 extension with a GPLv3 license, Screenity can be self-hosted by loading the unpacked extension from the GitHub releases page, making it viable for organizations with strict IT policies against Chrome Web Store installations. The architecture ensures all processing stays on-device when running in local mode, with no API calls or telemetry active.

What You Get

• Unlimited screen and camera recording - Record any tab, application window, desktop, or camera feed with no time limits, no watermarks, and no restrictions on recording count.
• Real-time annotation tools - Draw freehand, add text, arrows, shapes, and use an intelligent eraser directly on your screen while recording, powered by Fabric.js canvas.
• AI-powered camera background effects - Use MediaPipe machine learning to blur or replace your camera background in real time for professional-quality recordings.
• Cursor and click highlighting with spotlight mode - Automatically emphasize mouse movements, clicks, and use a spotlight overlay to guide viewer attention to key areas.
• Dual-encoder recording pipeline - Automatically selects between WebCodecs high-fidelity encoding and MediaRecorder fallback based on runtime browser capability, with encoder prewarming to eliminate startup latency.
• Built-in browser video editor - Trim, cut, crop, remove audio, and assemble clips using an FFmpeg WebAssembly-powered editor without leaving the extension or installing external software.
• Multiple export formats - Export recordings as MP4, GIF, or WebM, or save directly to Google Drive to generate a shareable link without a cloud subscription.
• Smooth zoom-in capability - Zoom into specific areas of the screen during recording with smooth animation to highlight details in tutorials and demos.
• Sensitive content blur - Pixelate or blur any region of the screen during recording to protect passwords, personal data, or confidential documents.
• Offline and self-hostable - Run entirely in local-only mode with no API calls or telemetry by loading the extension from the GitHub releases page as an unpacked extension.

Common Use Cases

• Software tutorial creation - A developer records their code editor and terminal with cursor highlighting and annotation arrows to walk viewers through a debugging process, exporting directly to MP4 for YouTube upload.
• Remote team async feedback - A product manager records a Figma prototype walkthrough with voiceover and drawing annotations, saves to Google Drive, and shares a link with the team — no recipients need an account.
• Privacy-sensitive education - A healthcare educator records lecture slides and camera feed with background blur enabled, running Screenity in offline mode so no student data ever leaves the institution’s device.
• Corporate-restricted environment demos - A developer in a locked-down corporate network loads Screenity as an unpacked extension without Chrome Web Store access, recording product demos without violating IT policy.
• Content creator screen capture - A streamer or YouTuber uses Screenity’s multi-resolution export (up to 4K via WebCodecs) and built-in clip trimming to produce polished demo videos without additional software.

Under The Hood

Architecture Screenity implements a rigorous multi-page extension architecture where each functional domain — Background service worker, Content script, Recorder, OffscreenRecorder, CloudRecorder, Editor, and EditorApp — operates as an isolated runtime boundary enforced by Webpack multi-entry compilation. Communication flows exclusively through a central message router and dispatcher abstraction that decouples all pages from each other. The Background service worker manages global state via Chrome storage and orchestrates complex recording lifecycle flows through lock-based coordination with explicit stale-lock cleanup on startup. React Context handles intra-page state management across isolated pages, while environment variables and Webpack aliases enable feature toggling between cloud and local builds without code bifurcation. The OffscreenDocument strategy for audio processing elegantly circumvents the MV3 service worker audio context restriction — a non-trivial engineering constraint most extension-based recorders fail to address cleanly.

Tech Stack Screenity is built as a Chrome Manifest V3 extension using React 18 with a Webpack multi-entry build system that generates isolated bundles for each extension page. The annotation layer runs on Fabric.js canvas, while media capture uses Chrome’s native tabCapture and desktopCapture APIs with a dual-path strategy: a MediaRecorder path for standard recordings and a WebCodecs-based recorder for high-quality encoding at resolutions up to 4K. Post-processing runs through FFmpeg WebAssembly and Mediabunny for container muxing. Camera background segmentation uses MediaPipe’s vision WASM model via the Tasks Vision API. The UI is built on Radix UI primitives for accessible controls, with SCSS module styling per page bundle. IndexedDB via localforage handles chunk storage, and Sentry provides production error telemetry.

Code Quality The codebase uses Playwright for end-to-end testing infrastructure (configured but with a lean test surface) and a unit test script pointing to a tests directory, though extensive unit test coverage is not present in the open-source release. Structured console logging with named prefixes and a dedicated debug logger utility reflects disciplined operational awareness. TypeScript is used selectively in the WebCodecs layer and type definitions while the majority of the codebase is JavaScript. Prettier and ESLint are configured and enforced via npm scripts. Heavy use of React refs and direct Chrome storage mutations in a concurrent multi-page messaging environment increases race-condition surface area, though the stale-lock recovery patterns in the Background script show awareness of these failure modes.

What Makes It Unique Screenity’s most technically distinctive contribution is its adaptive dual-encoder pipeline: the fastRecorderGate module implements a runtime capability probe that dynamically selects WebCodecs-based encoding or MediaRecorder fallback, with sticky failure state to avoid re-probing broken codec paths across sessions. Encoder prewarming pre-initializes capture streams before the user triggers recording to eliminate perceptible startup latency — a technique rarely seen in extension-based recorders. The canvas eraser uses per-pixel hit detection rather than object-level deletion, preserving layer integrity in complex multi-tool annotation sessions. The offscreen document architecture for audio isolation and the multi-resolution quality ladder (240p to 4K) with per-quality bitrate profiles round out an engineering approach that prioritizes reliability and fidelity over simplicity.

Self-Hosting

Screenity is released under the GNU General Public License v3.0 (GPLv3), one of the most protective copyleft licenses available. In plain terms, this means you can freely use, modify, and distribute Screenity for personal, educational, or internal organizational purposes. However, if you distribute a modified version — including as part of a commercial product or a managed service — you must release your modifications under GPLv3 as well. The project maintainer has explicitly noted that building a commercial product on top of Screenity requires reaching out for discussion, acknowledging that GPLv3’s copyleft requirements create real commercial considerations for anyone seeking to white-label or resell the tool.

Running Screenity yourself requires only Chrome and the extension files — there is no server infrastructure to maintain for the core recording and editing features, since all processing happens in the browser using WebAssembly (FFmpeg) and native Chrome APIs. Self-hosting means downloading the latest Build.zip from the GitHub releases page, enabling Chrome Developer Mode, and loading the unpacked extension folder. This approach works without internet access once loaded and involves zero ongoing operational burden beyond keeping the extension updated manually. The extension stores chunks and recordings in IndexedDB on the user’s device, so there are no external data stores to secure or back up.

The main trade-off of self-hosting compared to the official Chrome Web Store installation is the absence of Pro features: cloud storage via EU-hosted infrastructure, multi-scene editing with timeline support, zoom keyframes, automatic caption generation, and shareable video links all require a Screenity Pro subscription. Self-hosted instances also lack automatic updates and must be manually refreshed from GitHub releases. Enterprise users will also give up centralized deployment management — there is no MDM-compatible extension policy or admin console. Support is community-based through the GitHub issue tracker and the Screenity help center, with no SLA or priority support tier available outside of direct contact with the solo developer.