ShareX is a comprehensive screenshot, image editing, and file sharing application for Windows. It features a modular architecture with separate libraries for screen capture, image editing, uploading, helpers, history, and tools. The application supports capturing screenshots/recordings, applying annotations and effects, uploading to over 50 services, and includes various productivity tools. Built with .NET/C# using a mix of Windows Forms and Avalonia UI frameworks, it employs MVVM patterns, plugin architectures for extensibility, and cross-cutting helper libraries. The system handles data flows from capture through editing to upload/storage, with history tracking for user convenience.
OBS Studio is a cross-platform live streaming and recording application. Its architecture is modular: a core library (`libobs`) provides the runtime for sources, encoders, outputs, services, and filters, all registered via a plugin system. The frontend is a Qt-based desktop GUI (`frontend/`) that manages scenes, sources, audio mixing, and output controls. Graphics rendering is abstracted across Direct3D 11, Metal, and OpenGL backends. The system ingests video/audio from capture sources (screen, window, game, camera, hardware I/O like DeckLink), processes them through filters and encoders (x264, NVENC, QSV, AMF, FFmpeg), and outputs to streaming protocols (RTMP, WHIP, SRT) or local files (FLV, MP4, MOV). External dependencies include FFmpeg, Qt, libcurl, and various hardware SDKs. The codebase demonstrates strong engineering with reusable utility libraries (dynamic arrays, strings, config files, profilers) and a well-defined plugin API, though platform-specific code and bundled third-party SDKs introduce some technical drift.
RustDesk is a full-featured, open-source remote desktop application written primarily in Rust with a Flutter frontend. In production, it enables remote control, file transfer, clipboard synchronization, audio/video streaming, TCP tunneling, printer sharing, and camera streaming across Windows, macOS, Linux, Android, and iOS. The architecture is a client-server model with a rendezvous/relay server for NAT traversal, a plugin system for extensibility, and platform-specific backends for screen capture (DXGI, X11, Wayland, Quartz, Android MediaProjection), input simulation (enigo), and clipboard file transfer (RDP-based protocol with FUSE on Unix). Key entry points include `src/main.rs` (CLI), `src/server.rs` (host service), `src/client.rs` (remote session), and the Flutter UI in `flutter/`. Data flows involve encrypted peer-to-peer connections (NaCl), adaptive video codec selection (VP8/VP9/AV1/H264/H265 with hardware acceleration), and IPC via named pipes with OS-level authentication. External dependencies include libvpx, libyuv, FFmpeg, Opus, and platform-specific SDKs (Windows IddCx, macOS CoreGraphics, Linux Wayland/D-Bus). The codebase is actively maintained with frequent commits, CI/CD pipelines, and a large community (120k+ stars).
dpScreenOCR is a cross-platform desktop application for recognizing text from a selected screen region. It is built in C++ using the Tesseract OCR engine and Qt 5/6 for the graphical interface. The application runs as a system-tray utility: the user triggers a screen selection via a global hotkey, captures a portion of the screen, processes the image (grayscale conversion, upscaling, unsharp masking), and feeds it to Tesseract. Recognized text can be copied to the clipboard, added to a persistent history, or passed to an external executable. The architecture is modular, with separate libraries for OCR (dpso_ocr), system interaction (dpso_sys), image processing (dpso_img), network requests (dpso_net), sound playback (dpso_sound), configuration and history (dpso_ext), and a suite of cross-platform utilities (dpso_utils). Each module exposes a C API for C/C++ interoperability and includes platform-specific backends for X11 and Windows. The Qt UI provides a main window with recognition controls, a language manager for installing/updating Tesseract language packs, and export functionality for history. The project also packages a built-in gettext-compatible internationalization library (dp_intl) and supports 16 languages through Weblate. This is a pure application repository with no data analysis or machine learning training components. The code demonstrates solid engineering practices: clear separation of concerns, RAII resource management, comprehensive error handling, and an extensive CMake-based build system supporting multiple packaging formats (Unix bundle, Windows MSIX, Inno Setup). The test suite covers utility functions, geometry, SHA-256, version comparison, and platform-specific components, though the OCR pipeline itself has limited direct unit tests.
HyprQuickFrame is a native screenshot utility for Hyprland built using the Quickshell framework. It provides an overlay-based UI for capturing screenshots in region, window, or full-screen modes, with options to edit, save to disk, copy to clipboard, or share via KDE Connect. The application features shader-based dimming, animated transitions, and dynamic theme synchronization with wallpapers via Noctalia. The architecture centers around a QML application shell that manages state and delegates to specialized UI components (RegionSelector, WindowSelector, ControlBar, etc.). Screenshot capture is performed by spawning external processes (grim, wl-clipboard, editors) based on the selected mode. The theme system allows users to customize colors and animations via a TOML file, with a Python script available to sync colors from Noctalia-generated palettes. Key reusable components include a custom animated toggle button (QuickToggle.qml), a segmented control bar (ControlBar.qml), a TOML-based theme parser (Theme.qml), and a Noctalia theme synchronization script (sync_theme.py). These components are designed with minimal dependencies and demonstrate advanced QML animation techniques and configuration patterns.
Peekaboo is a mature macOS desktop automation toolkit that provides a CLI, Mac app, and MCP server for screen capture, UI element detection, input synthesis, window management, and AI agent integration. The architecture is modular: a Swift CLI (peekaboo) exposes ~33 commands for interaction, system control, and AI agent orchestration; a Mac app provides a menu bar interface, session management, and visualizer overlays; a bridge daemon (PeekabooBridge) enables secure remote automation via a versioned socket protocol with operation allowlisting. The MCP server exposes native automation tools to AI clients (Claude, Cursor, etc.) via stdio transport. The agent runtime (PeekabooAgentService) supports multiple AI providers (OpenAI, Anthropic, Ollama, etc.) with streaming, tool calling, and session persistence. The codebase is written in Swift 6.2 with strict concurrency, extensive unit/integration tests, and a focus on safety (fail-closed target validation, honest effect reporting). It is not a data research project; it is a production-grade application for macOS automation.
react-native-webrtc is a React Native native module that provides a JavaScript API for WebRTC, enabling real-time communication in mobile apps. It wraps Google's WebRTC library (via a fork by Jitsi) and exposes standard WebRTC objects like RTCPeerConnection, MediaStream, and RTCDataChannel to React Native. The architecture is a typical React Native native module: TypeScript bindings in src/ communicate with Android Java and iOS Objective-C native code through the bridge. Key entry points include the module's index.ts and the native WebRTCModule classes. The library handles media acquisition (getUserMedia, getDisplayMedia), peer connection management, data channels, screen sharing, and video effects. It includes example apps for iOS, macOS, and tvOS, but no production app. Reusable components include a custom EventEmitter for native event handling, a Permissions wrapper, and video effect processor interfaces. Maintenance is active with recent commits, but the library has some technical drift: it targets an older React Native version (0.71) in dev dependencies, uses synchronous blocking native methods that may be deprecated, and relies on a custom WebRTC fork that requires separate maintenance. No automated tests exist beyond linting.
XCap is a cross-platform screen capture library written in Rust, supporting Linux (X11, Wayland), macOS, Windows, and HarmonyOS (OHOS). It provides a unified API for capturing images of monitors and windows, as well as video recording (currently work-in-progress). The library abstracts platform-specific implementations behind common `Monitor`, `Window`, and `VideoRecorder` structs, using native APIs such as XCB, PipeWire, CoreGraphics, AVFoundation, GDI, Windows Graphics Capture, and OHOS PixelMap. It is well-structured with clean error handling and modular platform modules, though some features like Wayland capture and window recording are still incomplete. The codebase demonstrates solid Rust engineering practices and is actively maintained.
OpenScreen is a feature-rich, open-source desktop screen recording and video editing application built with Electron, React, and Pixi.js. It serves as a free alternative to Screen Studio, offering native screen capture on Windows (via Windows Graphics Capture, DirectShow, and WASAPI) and macOS (via ScreenCaptureKit and AVFoundation), with a browser-based fallback using getDisplayMedia. The application provides a complete post-production workflow including a timeline for zoom, trim, speed, annotation, and blur regions; automatic captioning using on-device Whisper (via Transformers.js); cursor overlay with smoothing, motion blur, and click bounce; webcam picture-in-picture with mask shapes; and export to MP4 (H.264 + AAC) and GIF with quality presets and a source-copy fast path. Architecturally, OpenScreen follows a multi-window Electron pattern with a main editor window, a floating HUD for recording controls, a source selector, and a countdown overlay. The renderer process communicates with the main process via a unified native bridge IPC channel, which exposes typed services for system, project, and cursor domains. Native capture is handled by platform-specific helper binaries (C++ for Windows, Swift for macOS) that stream video and cursor telemetry as JSON events. The editor uses Pixi.js for real-time compositing of video, webcam, cursor, annotations, and effects, with a spring-based physics system for smooth zoom and cursor transitions. The codebase demonstrates strong engineering practices with extensive unit and browser tests (Vitest + Playwright), internationalization across 12 locales, CI/CD pipelines for Windows, macOS, and Linux builds, and a Nix flake for reproducible development environments. However, the project is explicitly archived and no longer maintained; a community fork is recommended for continued development. The main editor component (VideoEditor.tsx) is notably large (~2000 lines), mixing state management, export logic, and UI, which presents a maintenance challenge. Despite this, many individual modules are well-isolated and reusable, particularly the export pipeline, cursor smoothing, captioning logic, and undo/redo hook.
AutoPy is a cross-platform GUI automation library implemented in Rust and exposed to Python through PyO3. It provides programmatic control of the mouse and keyboard, screen capture, bitmap pixel inspection, and color detection. The library abstracts over Windows, macOS, and X11 backends, so the same Python API works across desktop platforms. It is distributed as a Python extension module built with maturin/setuptools-rust and is also usable as a Rust crate.
SnapX is a cross-platform screenshot and screen recording tool, forked from ShareX, with extensive upload capabilities to dozens of services (image hosts, file storage, pastebins, URL shorteners). It features image effects (adjustments, filters, manipulations), OCR via PaddleOCR, QR code generation/scanning, hotkey automation, and clipboard monitoring. The application is built with Avalonia UI and .NET 10, targeting Linux, Windows, macOS, and FreeBSD. It includes a CLI, a native messaging host for browser integration, and a comprehensive settings system. The codebase is in early access with many features ported from ShareX but several stubs and incomplete implementations remain, particularly in screen recording, image annotation, and some uploaders. The architecture follows a core library (SnapX.Core) with separate UI (SnapX.Avalonia) and CLI projects, using MVVM pattern and dependency injection. While functional, the project exhibits significant technical debt and incomplete feature parity with its predecessor.