High-performance libraries and toolkits for building native desktop applications using the Rust programming language.
Iced is a cross-platform graphical user interface framework designed for building interactive applications with a focus on type safety and predictable state management. It utilizes a declarative architecture that separates application state, update logic, and view rendering, allowing developers to construct complex interfaces by nesting reusable functional components. The framework distinguishes itself through an Elm-inspired message-passing pattern, where all user interactions are processed as discrete messages to ensure reliable state transitions. It employs an immediate-mode rendering paradigm and a constraint-based layout engine, which together ensure that the interface remains synchronized with the application state and responsive across varying screen sizes and operating systems. Beyond its core architecture, the project provides a comprehensive set of primitives for interface engineering. This includes tools for managing dynamic text, container alignment, and styling, all of which map to native graphical backends to maintain a consistent look and feel. The system relies on strict data modeling to prevent invalid states, ensuring that business logic remains maintainable and robust throughout the development lifecycle.
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.
Pake is a command-line tool that transforms web pages into standalone desktop applications. By wrapping web content in a lightweight native shell, it enables users to package existing websites as native software for Windows, macOS, and Linux. The tool functions as a cross-platform packager that bundles a minimal browser runtime with application assets into a single executable file. Unlike traditional browser-based frameworks, it utilizes a system-level webview to render content, providing a desktop experience that operates with reduced overhead. Users can customize the resulting applications by defining specific window dimensions, application icons, and user agent strings during the build process. The software manages communication between the native host and the webview layer to handle window events and ensure the application behaves according to the configured settings.
libui is a native C GUI library and cross-platform framework used to build desktop applications. It provides a unified C abstraction layer and a native widget toolkit that maps directly to the host operating system's original controls, windows, and menu bars. The project functions as a portable UI wrapper, employing platform-specific backends and a native-API wrapper to maintain visual and behavioral fidelity across different operating systems. It utilizes a C-language binding layer to ensure portability across various compilers and targets. The library covers native interface construction and window layout management through abstracted containers and alignment controls. It includes capabilities for user input event handling via callbacks, component visibility management, and manual event loop control to coordinate background tasks with interface updates.
This project is a cross-platform desktop application that wraps web-based interfaces into a standalone, native container. By utilizing a webview-based rendering engine, it allows users to access web services as local applications on Windows, macOS, and Linux without requiring a full browser installation. The application is built on a memory-safe backend that manages system-level tasks and facilitates secure communication between the web frontend and the native operating system. This architecture enables features such as system-tray integration for background execution and quick access, providing a more integrated experience than a standard browser tab. The software leverages a unified build pipeline to package web technologies into lightweight, efficient binaries. This approach ensures consistent functionality across different operating systems while maintaining a small footprint and optimized resource usage.
An audio server, programming language, and IDE for sound synthesis and algorithmic composition.
This library is an immediate mode graphical user interface toolkit that reconstructs the entire interface every frame. By executing procedural code within a high-frequency loop that matches the display refresh rate, it allows developers to define interactive elements and state updates directly. The framework utilizes a multi-pass rendering approach to resolve layout dependencies, ensuring that widget sizes and positions are calculated accurately before final placement to prevent visual jitter. The project functions as a cross-platform graphics toolkit, providing a portable rendering layer that abstracts hardware-accelerated drawing commands across various operating systems and web browsers. It remains backend-agnostic by delegating low-level draw calls to modular integration layers, while its CPU-based tessellation generates geometry for shapes and text before sending them to the graphics hardware. This architecture supports low-latency performance, making it suitable for resource-constrained environments and real-time applications. Beyond its core rendering capabilities, the framework includes a coordinate-based hit-testing system for input-event dispatching and manages widget interaction priorities for overlapping elements. It provides tools for state-persistence serialization, performance profiling, and multi-viewport management. The system is designed to be configured during the build process, allowing for the inclusion of optional features such as parallel tessellation and interoperability with external math or color libraries.
wxWidgets is a C++ UI toolkit and cross-platform GUI framework used to develop desktop applications for Windows, macOS, and Linux. It functions as a native widget wrapper, providing an abstraction layer that maps a single set of API calls to the native interface elements of different platforms. The framework allows for the creation of native graphical user interfaces by utilizing the host operating system's own controls and APIs. This ensures that applications maintain a native look and feel across various operating systems while using a consistent codebase. Beyond interface development, the toolkit provides standardized system functions for network communication, background threading to keep interfaces responsive, and the integration of 3D graphics.
This project is a Java GUI framework used to build cross-platform desktop, mobile, and embedded applications. It centers on a hardware accelerated graphics engine that provides 2D and 3D visualizations and visual effects, complemented by a reactive UI binding system for synchronizing data and interface updates. The framework distinguishes itself through the FXML markup language, which separates the visual structure of an interface from its procedural logic. It also includes a dedicated CSS styling engine that allows for the customization of component appearances using external stylesheets and media queries. Its broader capabilities cover multimedia application development, including audio and video playback and web content rendering. It provides tools for data visualization via scientific charts and dashboards, as well as support for automated UI testing through a headless runtime mode. The project supports the creation of cross-compiled SDKs for various target platforms and can be integrated as modules into a development kit distribution.
Nativefier is a command-line tool that transforms web applications into standalone desktop software. By wrapping web content within a cross-platform container, it enables users to run websites as native applications on Windows, macOS, and Linux. The tool functions as a build-time orchestrator that packages a browser runtime with specific site configurations and platform-specific metadata. It allows for extensive customization of the resulting application, including the ability to inject custom JavaScript and CSS to modify site behavior or appearance. Developers can also utilize the tool programmatically within a Node.js environment to automate the generation of desktop binaries from web URLs. Beyond basic wrapping, the software provides granular control over the embedded browser environment. This includes managing window geometry, configuring user agent strings, and supporting protected video playback through content decryption modules. It also handles persistent application state, such as cache management and window position tracking, to ensure a consistent desktop experience.
Qv2ray is a multi-protocol proxy client and a graphical user interface for managing V2Ray network proxy connections. Built as a cross-platform desktop application, it provides a consistent visual experience for configuring traffic routing across Linux, Windows, and macOS. The application utilizes a plugin-based architecture that allows for the integration of third-party extensions to add support for additional network proxy protocols. This modular system enables the software to be extended without modifying the core binary. The tool covers multi-protocol proxy routing for tunneling protocols such as VMess, VLESS, Trojan, and SOCKS5. It includes interfaces for proxy connection management to control network settings and monitor active connection states.
Wails is a cross-platform framework for building native desktop applications by combining a Go backend with web-based frontend technologies. It enables developers to create lightweight software by utilizing the host operating system's native web rendering engine, eliminating the need to bundle heavy browser dependencies. The framework distinguishes itself through a robust communication layer that bridges the backend and frontend. It automatically generates type-safe JavaScript bindings and proxies from Go code, allowing for seamless, asynchronous method invocation and data serialization across the language boundary. This integration is supported by a comprehensive command-line interface that manages the entire project lifecycle, from scaffolding and template generation to the final compilation of single, portable native binaries. Beyond its core communication and build capabilities, the project provides a unified runtime library for accessing system-level features such as window management, menus, and file dialogs. It includes a live development environment that monitors source code changes to trigger incremental builds and automatic interface refreshes, ensuring a responsive development cycle. The framework is designed to be installed via standard package managers, providing tools to verify system dependencies and streamline the distribution of production-ready applications.
This project is an immediate-mode graphical user interface library designed for rapid development of tools and debugging interfaces. By generating UI geometry every frame through procedural code, it eliminates the need for persistent state synchronization between application data and the interface. It is primarily intended for integration into existing rendering pipelines, where it produces raw vertex buffers and draw commands that are agnostic to the underlying graphics API. The library distinguishes itself through a highly decoupled architecture that supports complex, dockable, and multi-viewport layouts. It manages window positions, tab dragging, and node splitting, allowing developers to detach interface elements into independent operating system windows. To ensure consistent interaction across diverse environments, it maps native input events into a unified format and provides robust identifier-based scoping to track element states across frames. The framework offers a broad capability surface for building sophisticated engine tooling and diagnostic utilities. It includes support for advanced visual components such as node editors, 2D and 3D plotters, and specialized inspectors, alongside infrastructure for DPI scaling and custom shape rendering. The system is designed for high portability, featuring compile-time configuration options that allow developers to adapt core data structures and mathematical types to specific engine requirements. The repository provides extensive examples for connecting the library to major graphics backends and frameworks, alongside tools for generating language-specific bindings.
ScottPlot is a cross-platform, high-performance charting library for .NET that renders interactive plots across desktop and web GUI frameworks including Windows Forms, WPF, MAUI, Avalonia, Blazor, and WinUI. It provides an optimized rendering engine capable of displaying millions of data points with interactive pan, zoom, and live data streaming, while also supporting image export to formats like PNG and SVG for file output, cloud applications, and notebooks. The library distinguishes itself through a comprehensive set of chart types including scatter, line, bar, pie, heatmap, financial, radar, polar, and statistical plots, all built on a plottable object model where each chart element manages its own rendering and styling independently. It offers scientific-grade customization of axes, ticks, labels, colormaps, and annotations, along with specialized coordinate systems for polar, Smith chart, triangular, and radar displays. Interactive elements such as draggable lines, markers, spans, and rectangles respond to mouse input without manual event wiring, and the library includes statistical visualization capabilities for histograms, box plots, regression lines, and probability density estimates. The library supports embedding plots in MVVM applications, rendering in .NET interactive notebooks, and generating plots in serverless or cloud environments without a GUI. It provides layout composition for arranging multiple plots in grids with shared axes, and includes automatic font detection for international text display.
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.
LCUI is a component-based, cross-platform UI toolkit for building desktop applications using C, TypeScript, and JSX. It provides a declarative UI compiler that transforms JSX and TypeScript markup into native C code, enabling developers to construct interfaces without a browser runtime. The library includes a CSS styling engine that applies standard CSS rules to layout and style native desktop components, and supports component composition with state management and event binding. The toolkit distinguishes itself by combining web development patterns with native desktop rendering, allowing developers to write interfaces using JSX and TypeScript that compile directly into executable code. It offers a component prototype system for defining custom components with lifecycle methods, and supports declarative XML interface loading for building component trees at runtime. The library includes density-aware scaling for adapting interfaces to different screen pixel densities, and provides flow and flexbox layout models controlled by CSS display properties. LCUI manages the full application lifecycle from initialization through the main event loop to shutdown, and binds user interactions to logic functions through its event handling system. It supports both Windows and Linux platforms from a single codebase, and offers project scaffolding to generate the necessary files and build configuration for new projects. The library can be integrated either through prebuilt binary installation or by including source code directly.
Avalonia is a cross-platform desktop framework that enables the creation of native-feeling applications for Windows, macOS, and Linux from a single codebase. It functions as a declarative UI toolkit, allowing developers to define complex visual hierarchies and interface structures using a markup-based syntax that maps directly to underlying object properties. By utilizing the Model-View-ViewModel architectural pattern, the framework facilitates a clean separation between application logic and user interface layout, which simplifies unit testing and component maintenance. The framework distinguishes itself through a custom rendering architecture that bypasses native platform controls, drawing user interface elements directly to the screen via platform-specific graphics APIs to ensure visual consistency. It employs a reactive data binding engine that synchronizes application state with UI properties, further optimized by a build-time compilation process that minimizes reflection overhead. Additionally, the framework supports deployment to web browsers via WebAssembly, allowing desktop-style applications to run in client environments without requiring server-side infrastructure. The platform provides a comprehensive suite of tools for interface construction, including a two-pass layout system that resolves complex parent-child constraints and a hierarchical property system that manages styling, animations, and local overrides. Developers can extend the framework through custom control authoring, utilizing specialized containers for responsive organization and event routing strategies that manage communication across the visual tree. The system also includes built-in support for headless testing and visual regression analysis to verify component behavior and layout accuracy.
V is a statically typed, compiled programming language designed for high-performance systems development. It prioritizes memory safety and execution speed by enforcing strict type checking and immutable defaults, while generating native machine code for multiple hardware architectures. The language is built around an integrated toolchain that includes a compiler, package manager, formatter, and testing utilities within a single executable, facilitating rapid development cycles. What distinguishes V is its focus on developer productivity and interoperability. It provides a direct interface for calling existing C libraries, allowing developers to integrate legacy codebases into a modern, type-safe environment. The language also supports compile-time logic execution and attribute-driven metadata processing, which automate tasks like JSON serialization and web routing without the overhead of heavy runtime reflection. Furthermore, V offers a unique approach to resource management, utilizing scoped cleanup and automated tracking to handle memory without requiring a traditional garbage collector. The project covers a broad capability surface, including native cross-platform desktop interface development, concurrent task synchronization via channels, and secure web backend services. It also features built-in support for database interactions, GPU shader compilation, and transpilation to JavaScript for browser-based execution. The entire toolchain is contained within a single, lightweight executable, and the project provides extensive documentation and a centralized module index to assist with dependency management and project organization.
Hyprland is a Wayland compositor and tiling window manager for Linux systems. It functions as a display server protocol implementation that coordinates communication between hardware and graphical applications, while automatically organizing open windows into non-overlapping layouts to maximize screen space. The project distinguishes itself through a dynamic tiling engine that utilizes a binary space partitioning algorithm to calculate window geometry in real time. It provides a highly customizable workspace platform where users define system behavior and visual aesthetics through declarative configuration files. To ensure low-latency performance, the compositor employs zero-copy memory mapping for graphical data transfers and utilizes an input device abstraction layer to normalize hardware signals. The system supports extensive personalization through a plugin-based architecture that allows for the injection of custom functionality and visual effects at runtime. It also includes capabilities for forcing native protocol support in applications and provides tools for performance-oriented system building, allowing users to compile components from source to tailor the environment to specific hardware and workflow requirements.
This project is a cross-platform UI framework and native desktop GUI library. It provides a unified set of instructions to render native windows, forms, and layouts across different operating systems by mapping high-level instructions to the native widgets and controls of the host environment. The toolkit includes a vector graphics engine for rendering custom shapes, gradients, and high-density images using brushes and matrices. It also serves as a native dialog provider for system-level operations such as file path selection and message box alerts. The library covers a broad range of GUI components, including tabular data visualization, various input pickers, and a flexible grid layout system for organizing interface elements. It also handles application lifecycle management, including window configuration and main-thread execution for thread-safe communication.