Desktop apps

PowerToys is a collection of background-resident system utilities designed to extend native operating system functionality and streamline desktop workflows. It operates as a modular toolkit, utilizing a central plugin-based host architecture that allows users to dynamically enable or disable specific features for system configuration and automation. By leveraging native system hooking, the suite intercepts global input and window events to provide advanced control over the computing environment. The project distinguishes itself through its focus on cross-device input orchestration and spatial window management. It enables users to synchronize peripherals and clipboard data across multiple networked computers, creating a unified multi-machine workstation. Additionally, it features a declarative window management engine that enforces custom grid zones and persistent overlay frames, allowing for granular control over window positioning and desktop organization. The toolkit encompasses a broad range of productivity and system management capabilities, including keyboard-driven command launching, bulk file processing, and visual design aids. It integrates directly into the operating system shell to provide context-menu actions for file manipulation, image resizing, and registry inspection. Users can also customize system behavior through input remapping, environment variable management, and automated command-line tool suggestions.

Chat2DB is an AI-powered SQL client and multi-database management GUI. It serves as a centralized graphical interface for administering diverse relational and non-relational database engines, integrating large language models to transform natural language prompts into executable SQL statements and application code. The tool utilizes schema-aware prompt engineering to inject database metadata into AI requests, ensuring generated queries match the actual schema. It also functions as an AI data reporting tool, using artificial intelligence to create dashboards and visual reports directly from database content. The platform provides broad database administration capabilities, including visual table editing, schema synchronization across environments, and data migration between instances. It also includes utilities for SQL code formatting and automated application code generation. The software is delivered as an Electron-based desktop runtime.

Etcher is a cross-platform utility designed for creating bootable media by flashing raw disk images onto USB drives and SD cards. It functions as a desktop application that provides a graphical interface for low-level storage device management, ensuring data integrity through built-in validation during the writing process. The application utilizes a unified interface layer to map high-level commands to native system utilities, allowing it to operate consistently across different operating systems. It employs a stream-based data pipeline to pipe image contents directly to storage media, which minimizes memory usage during large write operations. To maintain system security, the tool delegates administrative disk access tasks to a background process. Beyond image deployment, the software includes capabilities for storage device maintenance, such as clearing partition tables and reformatting corrupted or unusable drives. It is distributed through various native package managers and community repositories across Windows, macOS, and Linux environments.

Insomnia is a cross-platform API development environment that integrates a request debugger, schema design tools, a mocking server, and a test automation framework. It provides a unified workspace for sending requests and analyzing responses across REST, GraphQL, gRPC, and WebSocket protocols. The platform enables the design and preview of API specifications through a visual editor and allows for the simulation of backend behavior using mocking tools. It supports organizing and synchronizing API collections via local storage, cloud synchronization, or Git. The suite includes a command-line interface for executing linting and testing tasks within continuous integration pipelines. It also features a plugin system for third-party extensions and a secure system for storing environment variables locally to protect sensitive credentials.

Yazi is a high-performance terminal file manager designed for keyboard-driven navigation and organization of local file systems. Built as an asynchronous application, it utilizes a non-blocking runtime to execute concurrent file operations and interface updates, ensuring the user experience remains responsive even during intensive tasks. The interface is rendered directly into the terminal emulator using escape sequences to maintain minimal memory overhead. The application distinguishes itself through a modular architecture that supports custom functionality via an embedded scripting engine. It leverages specialized terminal protocols to render rich media previews directly within the viewport, offloading resource-heavy tasks like image processing to background worker processes. This design allows for a consistent file management experience across Linux, macOS, and Windows environments. Beyond its core navigation capabilities, the tool provides extensive support for system integration and environment management. Users can deploy the software through various package managers, including support for declarative configuration systems to ensure consistent behavior across different machines.

This project is a cross-platform terminal emulator that functions as a graphical frontend for command line shells. It operates by managing shell processes through a pseudoterminal emulation layer, capturing raw character streams to display them within a native desktop windowing environment. The application distinguishes itself through a specialized rendering engine that simulates the visual characteristics of vintage cathode ray tube hardware. By utilizing fragment shaders, it applies real-time effects such as scanlines, screen curvature, and phosphor glow directly to the terminal output. Users can further modify the interface through a declarative layout system and configuration files that allow for the adjustment of visual parameters and terminal behaviors. The software provides a comprehensive environment for terminal interface customization, supporting the preservation of historical computing aesthetics within modern operating systems. It is designed to be compiled from source to ensure compatibility with local system environments.

Handy is a local speech-to-text automation tool designed to convert spoken audio into text and inject it directly into active desktop applications. By running machine learning models entirely on the host hardware, it provides a private, offline-first environment for dictation and command execution. The system functions as a background service that manages microphone input, transcription state, and text output, enabling hands-free typing across various software environments. The project distinguishes itself through a modular pipeline that integrates local language models for post-transcription refinement. Users can configure custom prompts to automatically format, translate, or correct raw speech output before it is inserted into the target application. This workflow is further enhanced by event-driven automation hooks, which allow the system to trigger custom scripts, keyboard shortcuts, or command sequences in response to transcription events. Beyond core dictation, the software offers extensive control over the transcription environment, including hardware-aware audio management and real-time translation capabilities. It supports fine-grained adjustments to transcription accuracy, such as vocabulary correction for technical terminology and configurable input latency. The system also maintains a history of past sessions and provides tools for managing clipboard states and system memory usage.

LocalSend is a cross-platform utility designed for secure, peer-to-peer file transfers between devices on the same local network. By establishing direct, encrypted communication channels, the application enables users to share files without relying on external servers, cloud storage, or active internet connectivity. The project distinguishes itself through a unified codebase that supports native-looking interfaces across desktop and mobile operating systems. It utilizes automated peer discovery to identify available devices on a subnet and employs end-to-end encryption to ensure data integrity and confidentiality during every transfer. The software suite includes comprehensive build orchestration, allowing for the generation of native installation packages for Windows, macOS, Linux, Android, and iOS from a single source. Additionally, the project maintains multi-language support through a structured, community-driven localization system that decouples text strings into external files.

Redox is a POSIX-compliant, microkernel-based operating system written entirely in Rust. By utilizing a memory-safe language for the kernel and all system components, the project eliminates common vulnerabilities such as buffer overflows and use-after-free errors. Its architecture relies on a minimal kernel that manages only essential hardware and process isolation, delegating all other system services to unprivileged user-space processes. The system distinguishes itself through a modular design where hardware drivers and system services run as independent user-space daemons, allowing them to be updated or restarted without a full system reboot. Communication between these components is handled through structured message-passing rather than shared memory, ensuring strict isolation. Furthermore, Redox employs a unique scheme-based resource access model, where hardware, services, and system resources are exposed as file-like objects accessed through a unified URI-based naming convention. The operating system provides a comprehensive environment for general-purpose computing and development, including a standard library that enables the execution of existing Unix-like software with minimal modification. It supports multiple CPU architectures and includes a robust suite of tools for build automation, package management, and system image generation. These utilities allow developers to cross-compile software, manage dependencies, and test system variants within virtualized environments. The project is maintained as an open-source repository with extensive documentation and tooling to support custom kernel builds and system-level development.

This project is a comprehensive directory of open-source iOS applications designed to serve as a technical reference for developers and learners. It functions as a curated index of mobile software, categorizing projects by their functionality, implementation language, and architectural design to provide a clear view of how professional applications are structured. The repository distinguishes itself by offering a deep dive into mobile app architecture, allowing users to study real-world codebases that utilize patterns such as Model-View-ViewModel, VIPER, and Clean Architecture. It highlights how these structures support complex application requirements, including the integration of platform-specific technologies like ARKit, CoreML, WidgetKit, and WatchOS. By showcasing diverse implementations, the directory provides a practical look at how developers manage state-driven components and modular UI elements within the Apple ecosystem. Beyond native iOS development, the collection covers a broad spectrum of mobile engineering practices, including cross-platform development strategies using frameworks like Flutter, React Native, and Kotlin Multiplatform. It also catalogs various integration strategies, such as reactive data binding and asynchronous message passing, which are essential for maintaining synchronized and responsive user interfaces. The directory is organized as a technical catalog, making it a resource for discovering high-quality, community-maintained projects that demonstrate standard industry practices. It serves as a starting point for developers looking to explore specific API integrations, UI patterns, and hardware-access implementations across a wide range of application categories.

Lively is a desktop wallpaper engine for Windows that renders videos, web pages, and interactive shaders as dynamic, animated backgrounds. It functions by creating a transparent window layer behind desktop icons, utilizing native system handles to integrate content directly into the workspace. The application provides tools for system personalization, including the ability to adjust taskbar transparency and application themes to modify the visual style of the operating system. It also includes a command-line interface that allows for the automation of background playback and system configuration settings through external scripts. The software leverages native multimedia frameworks and hardware acceleration to process high-definition video and graphical content. It manages these background elements and system settings through an inter-process communication system that coordinates between the user interface and the background service.

QtScrcpy is a cross-platform desktop application designed for mirroring and controlling Android devices. It functions as a high-performance client that captures mobile display output and streams it to a computer monitor, enabling real-time interaction through a persistent connection. The application distinguishes itself by supporting the simultaneous management of multiple mobile devices from a single interface, allowing for batch operations and synchronized inputs. Users can map standard desktop mouse and keyboard actions to mobile touch events using custom scripts, facilitating efficient navigation and control. The software utilizes hardware-accelerated decoding to maintain low latency during screen casting and supports both wired and wireless connections to mobile hardware. Beyond basic mirroring, the tool provides capabilities for file transfers, clipboard synchronization, and media recording. It includes a graphical interface for configuring device services and executing custom commands, which assists in mobile application testing and debugging workflows. The project is built using a cross-platform framework, ensuring consistent functionality across Windows, macOS, and Linux environments.

This project is a cross-platform development framework and managed runtime environment designed for building high-performance applications. It provides a comprehensive toolkit for constructing web services, cloud-native microservices, and desktop applications, utilizing a unified runtime that handles memory management and execution across diverse operating systems. The framework distinguishes itself through a native ahead-of-time compilation toolchain that transforms source code into optimized, self-contained machine code binaries. This capability enables fast startup times and reduced memory footprints, while the built-in dependency injection container and layered configuration system provide a structured approach to managing application lifecycles, service lifetimes, and complex configuration data. Beyond its core execution model, the project includes extensive support for observability, data persistence, and background task orchestration. It offers standardized libraries for networking, cryptography, and serialization, alongside tools for containerization and the modernization of legacy codebases. Developers can leverage these features to build intelligent, data-driven applications that integrate with modern AI services and distributed systems. The project provides command-line tools for managing development environments, SDK versions, and build workflows, with documentation and installation scripts available to support setup across various host environments.

WinApps is a utility designed to run Windows applications within a virtualized environment while integrating them directly into a Linux desktop. By utilizing remote desktop protocols to stream graphical interfaces, the software allows virtualized programs to appear and behave as if they were installed natively on the host operating system. The project distinguishes itself by automating the discovery and configuration of these applications. It scans the guest registry to identify installed software and automatically generates desktop entries and shortcuts, enabling users to launch Windows programs directly from their host application menu. Furthermore, it manages the lifecycle of virtual machines, including power state control and resource orchestration, directly from the host environment. Beyond core execution, the system provides comprehensive file and protocol integration. It maps host directories into the virtual machine to facilitate data access and intercepts file open requests on the host to ensure that documents are routed to the appropriate guest application. These capabilities are managed through a configuration-driven approach that simplifies the deployment and maintenance of virtualized software environments.

This application is a high-performance media player designed for desktop environments, providing a unified interface for managing audio and video playback across local files and remote network streams. It supports a wide range of file formats and streaming protocols, utilizing native system frameworks and hardware-accelerated decoding to ensure synchronized, low-latency output. The player distinguishes itself through an extensible plugin architecture that allows for deep customization of the playback experience. Developers can build modular components to automate workflows, register custom commands, and integrate external data sources. This framework is supported by a web-based rendering engine that enables the creation of interactive overlays and custom control panels using standard web technologies directly within the application window. Beyond core playback, the software provides a comprehensive set of tools for managing media states, including subtitle and audio track selection. The system facilitates communication between the core engine and external extensions through structured messaging, allowing for stable, asynchronous interaction between the player and custom-built features.

Magpie is a desktop utility designed to enhance the visual fidelity and resolution of running applications through real-time graphics post-processing. It functions by intercepting the desktop frame buffer and applying spatial reconstruction and interpolation algorithms to upscale visual content during active playback. The system distinguishes itself by integrating a programmable graphics pipeline that allows for the injection of custom shaders directly into the display stream. Beyond visual enhancement, it provides an automation interface that enables programmatic control over application behavior and scaling settings by establishing a communication bridge between external scripts and the target software. The tool supports a broad range of capabilities, including the application of custom visual effects and the automation of interaction through synthetic input injection. These processes are managed through an asynchronous pipeline that decouples frame capture from transformation tasks to maintain performance during intensive image manipulation.

ExplorerPatcher is a system utility designed to modify the behavior of the Windows shell by injecting custom code into core operating system processes. It functions as a background patching tool that intercepts internal function calls and replaces modern interface components with legacy alternatives, allowing for the restoration of traditional taskbar, menu, and task switcher behaviors. The project distinguishes itself through its use of dynamic link library injection and side-by-side binary replacement to alter the desktop environment at runtime. By redirecting execution flow within the system explorer process, it enables granular customization of workspace layouts and navigation patterns that are otherwise unavailable in modern operating system versions. Beyond its core restoration capabilities, the tool provides a comprehensive suite of settings for managing desktop workspace configurations and visual preferences. It includes an integrated update management system that automates the retrieval of binary packages, supports custom update server definitions, and offers an opt-in channel for pre-release features. All user preferences and configuration settings are persisted through the system registry to ensure consistency across reboots.

Darling is a translation layer that enables the native execution of unmodified macOS binaries on Linux systems. It functions as a compatibility environment that maps macOS-specific system calls and environment variables to the host Linux kernel, allowing desktop applications to run without the need for full hardware virtualization or emulation. The project achieves this by implementing a user-space kernel emulation environment that intercepts and translates kernel traps into their Linux equivalents. It includes a custom loader for binary files that resolves dependencies against open-source implementations of Apple system frameworks, while managing the translation of thread-specific memory structures and inter-process communication mechanisms required by macOS applications. This environment bridges the gap between operating systems by providing the necessary infrastructure to execute proprietary software designed for Apple hardware directly on Linux distributions. The project is distributed as source code intended for compilation on Linux systems.

BetterDisplay is a comprehensive display management utility and virtual display engine designed to provide granular control over monitor configurations. It functions as a low-level hardware controller that interacts directly with graphics drivers and system APIs to override manufacturer limitations, enabling users to manage resolution, scaling, brightness, and color profiles across complex multi-monitor setups. The project distinguishes itself through its ability to generate synthetic virtual displays and inject custom framebuffers into the graphics pipeline, allowing for arbitrary resolutions and screen mirroring to specialized hardware. It provides advanced visual comfort features by manipulating GPU color tables and hardware-level settings to disable temporal dithering and mitigate pulse-width modulation flicker. These capabilities are supported by a robust automation toolkit that exposes display controls through command-line interfaces, network-accessible web requests, and system-wide notification buses. Beyond core configuration, the software facilitates workflow integration by allowing users to synchronize brightness across heterogeneous displays, calibrate HDR output, and automate settings through custom shortcuts or external scripts. It serves as a centralized hub for managing both physical hardware and virtual workspaces, ensuring consistent visual performance and display behavior across diverse environments.

Electronic WeChat is an Electron-based desktop chat client and wrapper for the WeChat messaging service, designed for macOS and Linux. It provides a functional messaging interface that integrates with native operating system notifications and system trays. The client includes a message recall blocker that prevents senders from retracting or deleting messages after they have been delivered, ensuring the recipient retains a permanent record of the conversation. It also features a URL redirect bypass to open destination websites directly in the default web browser. The application supports standard chat workflows, including group mentions and drag-and-drop media sharing. It also allows users to push subscribed content to external social media platforms and email services via API connections. The software is distributed through system-specific package managers to streamline installation across different regional distributions.