Tauri

Tauri is a cross-platform framework for building desktop applications that combine web-based user interfaces with a memory-safe systems-language backend. It functions as a secure runtime that hosts web content within native windowing containers, allowing developers to leverage existing web technologies while maintaining high-performance native logic. By compiling applications into small-footprint, platform-specific binaries, the framework avoids bundling heavy runtime environments, resulting in lightweight executables.

The project distinguishes itself through a capability-based security model that enforces granular access control over system resources and native APIs. Communication between the isolated frontend webview and the privileged backend is managed through a secure, asynchronous message-passing bridge. This architecture ensures that native system capabilities are exposed to the web interface only through strictly defined, configuration-driven permissions.

The framework provides a modular plugin system that allows for the extension of core functionality through reusable backend components. Development is supported by a unified workflow that includes project scaffolding, a local development server with hot-reloading for both frontend and backend assets, and automated tools for managing the application lifecycle and binary distribution. The system also includes built-in support for orchestrating remote application updates and verifying package integrity.

Features

Webview Runtimes - Hosts web content within native windowing containers while enforcing secure access to underlying system capabilities.
Cross-Platform Desktop Frameworks - Enables the construction of desktop applications by pairing web-based user interfaces with memory-safe systems-language backends.
Native Binary Bundlers - Orchestrates the compilation of source code and platform-specific assets into signed, distributable native binaries.
Bridge Interfaces - Facilitates secure message-passing between frontend web contexts and native backends for seamless data exchange.
Desktop Application Runtimes - Combines high-performance backend logic with native window management to create cross-platform desktop execution environments.
Permission-Based Native Bridges - Exposes native system APIs to web frontends through a strictly controlled, permission-based interface layer.
Ahead-Of-Time Binary Bundlers - Bundles application code, assets, and runtime components into optimized, platform-specific executables.
Policies - Restricts access to sensitive system resources using a granular, configuration-driven security policy enforced at runtime.
Application Packaging - Packages source code and assets into platform-specific installers and distribution artifacts for desktop and mobile environments.
System-Webview-Based Renderers - Displays user interfaces by embedding the host operating system's native webview component within a secure application window.
Asynchronous Message-Passing Bridges - Coordinates bidirectional, asynchronous communication between web-based frontends and native backends using serialized message passing.
Application Plugins - Extends core functionality through isolated, reusable backend modules that integrate directly into the application runtime.
Infrastructure Deployment - Lightweight framework for building desktop apps with web technologies.
Application Frameworks - Framework for building small, fast, and secure cross-platform applications.
Architecture Documentation - Discusses architectural considerations and maps important dependencies.
Cross-Platform Development - Secure desktop application framework.
Frameworks and Tooling - Framework for building lightweight cross-platform desktop applications.
Frontend Frameworks - Build smaller, faster, and more secure desktop apps with web frontends.
Hybrid App Frameworks - Listed in the “Hybrid App Frameworks” section of the Awesome Mac awesome list.
Personal Productivity and Utilities - Framework for building lightweight desktop and mobile applications.
Development Lifecycle Managers - Automates the development lifecycle through command-line utilities that manage builds, dependencies, and packaging workflows.
Capability-Based Security - Defines explicit permission scopes to restrict application authority over system resources and sensitive runtime operations.
Memory-Safe Backend Orchestrators - Manages application logic using a memory-safe systems language to prevent common vulnerabilities during native task execution.
Development Servers - Launches local development servers featuring hot module reloading for frontend assets and automatic backend recompilation.
Plugin Systems - Provides a modular architecture that allows developers to inject custom backend logic and bridge native interfaces.
Unified Full-Stack Hot-Reloaders - Synchronizes frontend web updates with native backend compilation to enable a unified, hot-reloading development workflow.
Project Scaffolding - Bootstraps new projects with standardized file structures and pre-configured templates to accelerate cross-platform application setup.
Application Lifecycle Managers - Coordinates system-level interactions and process management within the backend runtime to ensure consistent cross-platform execution.

electron/electron

121,727View on GitHub

This framework provides a multi-process architecture for building desktop applications using web technologies. It manages the application lifecycle, window states, and system-level integrations through a primary entry point, while isolating web content in separate rendering processes to maintain stability and security. A secure bridge mechanism facilitates communication between these isolated contexts and the main process, ensuring that privileged system APIs remain protected. The framework distinguishes itself through a comprehensive security model that includes process sandboxing, content p

nwjs/nw.js

41,183View on GitHub

nw.js is a Node.js desktop application framework that combines a Chromium web renderer with a Node.js runtime to build standalone software for Windows, macOS, and Linux. It serves as a cross-platform desktop runtime that allows developers to create native executables using web technologies. The project is distinguished by its integration layer that exposes Node.js system APIs and modules directly to the browser window and web worker contexts. It functions as a native module bridge, enabling the compilation and execution of low-level C++ system code and native addons within a web-based applica

vuejs/vue

209,900View on GitHub

Vue is a progressive, component-based JavaScript framework designed for building reactive user interfaces and single-page applications. It centers on a declarative template system that transforms HTML into efficient render functions, allowing developers to organize complex interfaces into isolated, reusable units that synchronize automatically with application state. The framework distinguishes itself through a dependency-tracking reactivity system that monitors data access during rendering to trigger precise updates. It provides a flexible architecture that supports both incremental adoption

neutralinojs/neutralinojs

8,543View on GitHub

Neutralinojs is a lightweight cross-platform desktop application framework that allows developers to build native applications using web technologies and a C++ backend. It serves as a native system API bridge, enabling JavaScript frontend code to execute system commands and manage files across Windows, macOS, and Linux. The project distinguishes itself as a portable runtime that renders interfaces via the system's built-in webview instead of bundling a full browser engine. This approach enables the packaging of web assets into small, standalone executable binaries. The framework provides com

tauri-appstauri

Features