scrcpy is a high-performance desktop application that mirrors and controls Android devices over USB or TCP/IP. The client is a native C application using SDL3 for rendering and input, FFmpeg for media decoding, and libusb for USB-OTG mode. The server is a Java service running on the Android device that captures screen and audio via MediaCodec and hidden Android APIs, streaming them over an ADB tunnel. The system supports multiple input modes (SDK injection, UHID, AOA HID), video/audio recording, V4L2 loopback output, and clipboard synchronization. Architecture is client-server with a well-defined protocol, trait-based pipeline for frame/packet processing, and extensive cross-platform support (Linux, Windows, macOS).
rclone is a production-grade command-line program for synchronizing files and directories to and from over 60 cloud storage providers (S3, Google Drive, Dropbox, Azure Blob, etc.) and local filesystems. It implements a clean, modular architecture centered on the `fs.Fs` and `fs.Object` interfaces, which all backends implement. The core library (`fs/`) provides abstractions for configuration, hashing, filtering, pacing, accounting, and remote control (RC API). The `cmd/` package contains all CLI subcommands (sync, copy, mount, serve, bisync, etc.), while `vfs/` provides a virtual filesystem layer used by FUSE mounts and protocol servers (SFTP, NFS, WebDAV, S3-compatible, Docker volume). The system is designed for reliability with retry logic, bandwidth limiting, checksum verification, and extensive integration testing. Key entry points include `rclone.go` (main), the Cobra command tree in `cmd/`, and the RC HTTP server (`fs/rc`). Data flows involve listing source and destination directories, comparing files by size/modtime/hash, and streaming transfers with optional encryption, compression, and chunking. External dependencies include cloud SDKs (AWS, Google, Azure, etc.), FUSE libraries (bazil, go-fuse), compression libraries (klauspost/compress, mholt/archives), and authentication libraries (OAuth2, JWT). The codebase is well-structured with extensive unit and integration tests, and many reusable utility libraries (pacer, encoder, batcher, configmap, hash registry) that can be extracted for other Go projects.
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).
This repository contains a VS Code extension that acts as a bridge between the Antigravity IDE and a mobile device, enabling remote interaction via a local HTTPS server. The extension starts a self-signed HTTPS server on the LAN, uses the Chrome DevTools Protocol (CDP) to inspect and manipulate Antigravity IDE instances, and leverages the Language Server Protocol (LSP) to monitor and control code generation processes. A companion mobile web interface, served by the local server, provides real-time chat mirroring, message sending, file uploads, voice input, and generation control through a WebSocket connection. The architecture consists of three main parts: the VS Code extension (managing the server lifecycle and IDE integrations), the Express/WebSocket server (handling API requests, real-time communication, and static file serving), and the mobile SPA (rendering the IDE state and forwarding user interactions). Key capabilities include QR-code based pairing, end-to-end encrypted local communication, multi-instance switching, and programmatic control via an MCP server that exposes the API over stdio JSON-RPC. The extension demonstrates solid engineering practices with TypeScript, modular service layers, middleware for authentication and security, and a test suite covering core functionality. While tightly coupled to Antigravity's UI and protocols by necessity, it isolates concerns through well-defined services (CDP, LSP, antigravity interactions) and reusable patterns such as the CSP middleware, CDP wrapper, and stdio JSON-RPC proxy. Ongoing maintenance addresses selector fragility and API updates, ensuring compatibility with evolving IDE and VS Code versions.
SmsForwarder is an Android application written in Kotlin that monitors SMS messages, incoming calls, and app notifications on a device and forwards them to multiple third-party channels such as DingTalk, WeChat Work, Feishu, Telegram, email, Bark, Webhook, and others. It also provides a local HTTP server for remote control (query/send SMS, call logs, contacts, battery status, location, and Wake-on-LAN) and an automation engine with configurable conditions (cron, battery, network, Bluetooth, location, screen state, etc.) and actions (forward, send SMS, trigger alarm, control frpc tunnels, etc.). The architecture follows a standard Android pattern with Room database, WorkManager for background tasks, XUI for UI components, and a fragment-based navigation system. The codebase is large and feature-rich, with over 15 sender channels and a flexible rule engine, but exhibits some technical debt such as deprecated API usage, hardcoded vendor-specific intents, and a few large monolithic fragments.
This repository is an Android application that bridges device events (SMS, MMS, missed calls, battery changes, app notifications) to a Telegram bot for monitoring and remote control. It uses the Telegram Bot API to forward events and long-polls for incoming commands to send SMS, USSD, list/read/delete SMS, fetch logcat, and more. The architecture is a monolith with multiple background services, broadcast receivers, and job scheduler jobs, all within a single Android app. It uses MMKV for key-value storage, OkHttp for HTTP, Gson for serialization, and libsodium for encryption. The codebase is well-structured with reusable utility classes (e.g., custom Mustache template engine, Telegram API wrapper, encryption helpers) and has unit tests for several components. It supports multi-language, QR code configuration import, and carbon-copy forwarding to external services via HAR format.
Aspia is a comprehensive, cross-platform remote desktop and system administration suite. The codebase is decomposed into four primary components: a **host** (the machine being controlled), a **client** (the controlling machine), a **router** (session brokering and NAT traversal), and a **relay** (traffic forwarding). It supports Windows, Linux, macOS, and Android, with platform-specific implementations for screen capture (DXGI, X11, Wayland/PipeWire, KMS/DRM, Android MediaProjection), audio (WASAPI, PulseAudio, Oboe), input injection, and clipboard integration. The system uses encrypted communication with SRP authentication, X25519 key exchange, and AEAD ciphers (AES-256-GCM, ChaCha20-Poly1305) with key ratcheting. Beyond desktop sharing, it provides file transfer, text chat, remote terminal, task manager, system information collection, and video recording. The client features both a Qt-based desktop GUI and a custom Android UI built with native widgets. The router manages host discovery, two-factor authentication (TOTP), and relay session keys, while the relay handles peer-to-peer forwarding. The codebase is built with CMake, uses protobuf for messaging, and relies on libraries like asio, OpenSSL, libvpx, libyuv, and zstd.
InjectionIII is a macOS menu bar application that enables hot reloading of Swift, Objective-C, and C++ code in iOS simulators and devices. It works by watching for source file changes, recompiling them using Xcode build logs, and dynamically loading the resulting dylib into the running app using techniques like interposing, vtable patching, and Objective-C swizzling. The app consists of a daemon with a file watcher and injection server, while the client-side code (bundled as injection bundles or via the HotReloading Swift package) handles compilation and injection. It supports standalone injection without the app running, injection on real devices, and integration with SwiftUI. The codebase is mature and actively maintained, though it contains legacy C/ObjC components and is tightly coupled to Xcode build log parsing.
Apollo is a self-hosted game streaming server, forked from Sunshine and rebranded for compatibility with Artemis (formerly Moonlight Noir) clients. In production, it captures the host's display (via DXGI, KMS, Wayland, or NvFBC), encodes video using hardware encoders (NVENC, AMD AMF, Intel QSV, VAAPI, VideoToolbox) and audio (Opus), then streams over the network using a combination of RTSP for session control and ENet for real-time transport. It also forwards keyboard, mouse, gamepad, and pen input back to the host, enabling low-latency remote gaming or desktop control. The architecture is a single-process C++ application with a multi-threaded design: separate threads for video capture, encoding, audio capture, network I/O, and control. It exposes a web-based configuration UI (Vue.js frontend served by an embedded HTTPS server) and implements the NVIDIA GameStream HTTPS API for client pairing and session management. Platform-specific code is isolated behind abstraction interfaces (e.g., platf::display_t, platf::input_t), with dedicated implementations for Windows, Linux, and macOS. External dependencies include Boost, FFmpeg, OpenSSL, ENet, and vendor-specific SDKs (NVENC, AMF, VAAPI, etc.). The codebase demonstrates solid engineering with a clear separation of concerns, a comprehensive build system (CMake with platform macros), and a growing test suite (Google Test). However, it carries technical debt from its forked nature—some code still references 'Sunshine' while branding leans toward 'Apollo'—and there are incomplete features on macOS (e.g., placeholder functions for clipboard) and fragile workarounds for driver bugs. Overall, it is a functional, well-maintained application with reusable patterns for inter-thread communication, resource management, and platform abstraction.
Firemote is a Home Assistant custom dashboard card that emulates physical remote controls for a wide range of media devices including Amazon Fire TV, Apple TV, Chromecast, NVIDIA Shield, Roku, Xiaomi, and more. The card provides realistic visual remotes with extensive customization: over 330 app launcher shortcuts, button overrides via Home Assistant scripts or actions, multiple remote styles, and support for device-specific compatibility modes. It integrates with Home Assistant's Android Debug Bridge, Android TV Remote, Apple TV, and Roku integrations. The repository contains the compiled JavaScript card and supporting data files for device definitions and translations, but the source is distributed as a single minified bundle. It is actively maintained with a large community and frequent updates.