Skip to content
CAI
Software that uses CAICheck a score

tauri-apps/tauri

53.1

Adequate · 14 November 2026

104.8k

lines of production code

Rust

with TypeScript

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Isolation example demonstrating security pattern

A new example application named 'Isolation' has been added to the examples directory. It demonstrates the use of the isolation security pattern, configured via \tauri.conf.json\ to use the \isolation\ strategy with a specific output directory (\isolation-dist\). The example includes a simple Rust backend with a \ping\ command and a standard Tauri configuration, runnable via \cargo run --example isolation --features isolation\.

examples/isolation · high confidence

Add Tauri plugin sample example with mobile support

The plugin sample example now includes a complete implementation demonstrating how to build a Tauri plugin that works on both desktop and mobile platforms. The example features a \ping\ command that sends events via channels, a \js\_values\ command specifically for mobile to resolve JavaScript objects and arrays from native code, and proper error handling for mobile plugin invocations. It showcases the new plugin API including \PluginApi\ for registering Android and iOS plugins, and demonstrates how to structure a plugin with separate desktop and mobile implementations.

examples/api/src-tauri/tauri-plugin-sample · high confidence

Add Tauri schema generator crate with documentation assets

A new \tauri-schema-generator\ crate has been introduced to host the schema for the Tauri configuration file. The implementation currently provides an empty main entry point, but includes configuration for HTML documentation assets, specifically setting the logo and favicon URLs for the generated docs.

crates/tauri-schema-generator/src · high confidence

Add monitor work area API for Linux, macOS, and Windows

This change introduces a new \work\_area\ method to the \MonitorExt\ trait, allowing applications to retrieve the usable screen area (excluding taskbars, docks, or menus) on Linux, macOS, and Windows. The implementation provides platform-specific logic: on Linux it uses GTK's \workarea\, on macOS it calculates the visible frame relative to the screen frame, and on Windows it queries the \MONITORINFO\ structure via Win32 APIs. This enables developers to position windows or UI elements within the actual usable screen space rather than the full monitor bounds.

crates/tauri-runtime-wry/src/monitor · high confidence

Add resources example demonstrating asset resolution

A new example application located in \examples/resources/src-tauri\ has been added to demonstrate how to access bundled resources. The example configures \tauri.conf.json\ to include assets via the \bundle.resources\ pattern and uses the \path::BaseDirectory::Resource\ API in the Rust backend to resolve and read the content of \assets/index.js\ at startup.

examples/resources/src-tauri · high confidence

Add resources example demonstrating bundled asset resolution

A new example application has been added to showcase Tauri's bundle resources functionality. It demonstrates how to include a JavaScript file as a bundled resource and access it at runtime using the \resolveResource\ path API and the \read\_to\_string\ command, displaying the resolved file path and content in the browser UI.

examples/resources · high confidence

Add splashscreen example with main and splash HTML pages

The examples/splashscreen/dist directory now includes index.html and splashscreen.html files that demonstrate the Tauri splashscreen feature. The main window (index.html) uses the Tauri core invoke API to call close\_splashscreen after a 2-second delay, while splashscreen.html provides a full-screen styled overlay with a centered icon image.

examples/splashscreen/dist · high confidence

Add state management example

A new example application demonstrating how to manage and share application state across Tauri commands using Rust's \State\ API. The example includes a counter UI with increment, decrement, and reset functionality, showing how state persists across reloads.

examples/state · high confidence

Add webview zoom, print, and devtools hotkey scripts

New JavaScript scripts are injected into webviews to enable native-like keyboard and mouse interactions. Users can now zoom in and out using Ctrl/Cmd with +/- keys or the mouse wheel, reset zoom with Ctrl/Cmd+0, trigger the print dialog via the window.print() API, and toggle developer tools using platform-specific hotkeys (Ctrl+Shift+I on Windows/Linux, Cmd+Alt+I on macOS).

crates/tauri/src/webview/scripts · high confidence

Add window effects support for macOS and Windows

This change introduces a new \vibrancy\ module that enables platform-specific window effects. On macOS, users can now apply the Liquid Glass effect (with regular or clear styles, optional tint color and radius) or fall back to standard Visual Effect materials (such as Dark, Light, Titlebar, etc.) with configurable state and radius. On Windows, the module supports Mica (including Dark and Light variants), Acrylic, Blur, and Tabbed effects (including Dark and Light variants). The implementation delegates to the \window\_vibrancy\ crate and provides a unified \set\_window\_effects\ API to apply or clear these effects on Tauri windows.

crates/tauri/src/vibrancy · high confidence

Android CLI commands now support JSON, JSON5, and TOML configuration files

The \tauri android dev\, \build\, \run\, and \init\ commands now accept the \--config\ flag pointing to \.toml\ or \.json5\ files in addition to JSON. This allows developers to use their preferred configuration format for platform-specific overrides and build-time merges, simplifying configuration management for Android projects.

crates/tauri-cli/src/mobile/android · high confidence

Android template adds standard build and configuration files

The Android mobile template now includes essential scaffolding files: an .editorconfig for consistent code formatting, a .gitignore that excludes build artifacts and sensitive files like keystore.properties, and the Gradle wrapper scripts (gradlew and gradlew.bat) to ensure reproducible builds. These additions standardize the project structure and improve security by preventing accidental commits of sensitive configuration.

crates/tauri-cli/templates/mobile/android · high confidence

App template now includes a log plugin for debug builds

The generated Tauri application template now automatically registers the \tauri\_plugin\_log\ plugin when running in debug mode. This means developers will see log output at the Info level during development, aiding in debugging, while the plugin is not included in release builds to keep the application lightweight.

crates/tauri-cli/templates/app/src-tauri/src · high confidence

Command macro supports renaming and unused command removal

The \\#\[command\]\ macro now supports a \rename\ attribute to explicitly set the command name exposed to the frontend, overriding the default function name. Additionally, when the \REMOVE\_UNUSED\_COMMANDS\ environment variable is set, the macro automatically filters out commands that are not listed in the application's ACL, printing a warning for any removed commands. This helps reduce the attack surface by ensuring only authorized commands are available at runtime.

crates/tauri-macros/src/command · high confidence

Expanded NSIS installer localization support

The Windows NSIS installer now includes built-in language packs for Arabic, Bulgarian, Dutch, Hebrew, Italian, Japanese, Korean, Norwegian, Persian, Portuguese (including Brazilian), Russian, Simplified Chinese, Spanish (including International variants), and Swedish. Users can now select their preferred language during installation, ensuring installer prompts and WebView2 status messages are displayed in their native language.

crates/tauri-bundler/src/bundle/windows/nsis/languages · high confidence

Initial Android plugin framework and core APIs

This change introduces the foundational Android plugin infrastructure for Tauri, including the \PluginManager\ and \Plugin\ base classes that handle lifecycle events, command dispatch, and activity result callbacks. It adds the \AppPlugin\ to expose the \process.exit\ command and emit a \back-button\ event, and the \PathPlugin\ to resolve standard directories (home, config, data, cache, etc.) and resolve file names from Android content URIs. The diff also includes supporting utilities for file system operations (\FsUtils\), permission state management (\PermissionHelper\, \PermissionState\), JSON serialization (\JSObject\, \JSArray\), and logging (\Logger\), along with the necessary Kotlin annotations and a basic instrumentation test.

crates/tauri/mobile/android/src · high confidence

Initial Android plugin template for the sample API

The Android portion of the \tauri-plugin-sample\ example has been added, providing a functional plugin structure for mobile developers. This includes an \ExamplePlugin\ class that exposes commands like \ping\ and \jsValues\, demonstrating how to parse typed arguments, handle events via channels, and serialize JS objects/arrays. The entry also includes the necessary \AndroidManifest.xml\, a core \Example\ implementation class, and baseline unit and instrumentation tests to verify the package setup.

examples/api/src-tauri/tauri-plugin-sample/android · high confidence

Initial iOS API library release

The \crates/tauri/mobile/ios-api\ crate is introduced as a new Swift package providing the core iOS runtime for Tauri. This library includes the \PluginManager\ for handling plugin lifecycle and command invocation (supporting both synchronous and async \completionHandler:\ patterns), the \Invoke\ class for managing command arguments and responses, and utilities for JSON serialization, type coercion, and logging. It also establishes the foundational \Channel\ mechanism for event listeners and includes a \StdoutRedirector\ to capture stdout/stderr into \os\_log\.

crates/tauri/mobile/ios-api · high confidence

Initial implementation of the Wry-based runtime

This change introduces the \tauri-runtime-wry\ crate, providing the core runtime implementation for Tauri applications using the Wry webview library. It establishes the foundational architecture for cross-platform window and webview management, including platform-specific handling for Windows (WebView2), macOS/iOS (WKWebView), Linux (WebKitGTK), and Android. The implementation covers essential features such as window creation, focus management, DPI awareness, undecorated resizing, and webview permissions, serving as the bridge between Tauri's core API and the underlying webview engines.

crates/tauri-runtime-wry/src · high confidence

Initial release of tauri-driver as a cross-platform WebDriver intermediary

The \tauri-driver\ crate is introduced as a new component that acts as a WebDriver intermediary node for Tauri applications. It wraps the native WebDriver servers (WebKitWebDriver on Linux, Microsoft Edge Driver on Windows) to provide a unified interface for test frameworks. The driver listens on two ports (defaulting to 4444 for the client and 4445 for the native server) and supports configuring the application path, arguments, and webview options via the \tauri:options\ capability.

crates/tauri-driver · high confidence

Introduce Tauri Schema Worker for dynamic schema retrieval

A new background worker service has been added to serve Tauri configuration schemas dynamically. It exposes endpoints to fetch the latest stable schema, the latest pre-release (next) schema, and schemas for specific Tauri versions. The worker retrieves schema definitions from the Tauri repository, caches them for performance, and ensures responses are served with the correct JSON content type.

crates/tauri-schema-worker/src · high confidence

Introduce built-in development server with host validation

The Tauri CLI now includes a built-in development server (powered by Axum) that serves frontend assets and manages hot-reload via WebSocket. This server validates the Host and Origin headers on incoming requests to prevent DNS rebinding attacks, ensuring that only requests addressed to the local server are served. It automatically watches the project directory for file changes and triggers browser reloads, providing a secure, zero-configuration local development experience.

crates/tauri-cli/src/dev · high confidence

Introduce tauri-driver as a WebDriver intermediary for Tauri apps

A new \tauri-driver\ component is added to act as a WebDriver intermediary node, bridging standard WebDriver clients with the platform-specific native WebDriver servers (WebKitWebDriver on Linux, msedgedriver on Windows). This intermediary handles session capability translation, converting Tauri-specific options into native browser options (such as adding the \.exe\ extension for Windows binaries) and forwarding requests to the native driver. It manages the lifecycle of the native driver process, ensuring it does not inherit stdout to prevent output corruption, and supports configuration via command-line arguments for ports and driver paths.

crates/tauri-driver/src · high confidence

Introduction of the tauri-plugin crate for plugin development

A new \tauri-plugin\ crate has been added to provide the core interface for building Tauri plugins. This crate exposes a \build\ feature containing helpers for the plugin \build.rs\ script, including the \Builder\ for checking conventions, generating permissions, and linking mobile projects, as well as \plugin\_config\ for reading CLI configuration. It also includes a \mobile\ module to patch iOS \Info.plist\ and Android manifests. The \runtime\ feature is currently reserved and exports nothing, directing users to use \tauri::plugin\ for defining the plugin itself.

crates/tauri-plugin/src · high confidence

Mobile CLI commands now support pnpm, npx, and Deno execution contexts

The mobile initialization and build commands in the CLI now automatically detect and adapt to various JavaScript/TypeScript package managers. When invoked via pnpm (including \pnpm dlx\), npm, npx, or Deno, the CLI correctly identifies the binary and constructs the appropriate execution arguments, ensuring that mobile project generation and IDE script execution work seamlessly within these environments.

crates/tauri-cli/src/mobile · high confidence

New App plugin exposing core app information and control commands

A new \app\ plugin has been introduced in the Tauri core, exposing a set of commands to JavaScript/TypeScript clients for retrieving app metadata (version, name, identifier, Tauri version, bundle type) and controlling app behavior (show/hide on macOS, exit with code, set app theme, toggle macOS dock visibility, and check multi-window support). It also provides platform-specific data store management for Apple targets (fetching and removing data store identifiers) and registers the Android plugin bridge. This centralizes access to fundamental app-level properties and lifecycle controls that were previously unavailable or scattered.

crates/tauri/src/app · high confidence

New CI scripts for change-tag validation, license checks, and macOS crash reporting

The repository introduces several new CI helper scripts in \.scripts/ci/\ to enforce quality and support debugging. \check-change-tags.js\ validates that change files contain valid, known tags for configured packages, failing the build if tags are missing or unknown. \check-license-header.js\ scans source files to ensure they contain the required copyright and license headers. \collect-macos-crash-reports.sh\ automates the collection and formatting of macOS crash reports after failed e2e runs to aid in debugging app crashes. Additional scripts include \has-diff.sh\ to verify a clean working directory, \pack-cli.sh\ to package the CLI binaries, and \sync-cli-metadata.js\ to update CLI version metadata during versioning.

.scripts · high confidence

New CLI command to create capability files with validation

The Tauri CLI now includes a \capability new\ command (aliased as \create\) that guides users through creating capability definition files. This command prompts for a capability identifier, description, target windows, and permissions, then writes the resulting configuration to a JSON or TOML file in the \capabilities\ directory. The implementation adds strict validation for capability identifiers (allowing only ASCII alphanumeric characters, hyphens, and underscores to prevent path traversal) and permission identifiers, ensuring that generated files are safe and correctly formatted before being written to disk.

crates/tauri-cli/src/acl/capability · high confidence

New CLI commands to manage permissions and capabilities

The \tauri permission\ subcommand is now available, providing four new operations: \new\ to create permission definition files (supporting JSON and TOML formats with allow/deny command lists), \add\ to attach permissions to existing capabilities (preventing duplicates and avoiding file overwrites), \rm\ to remove specific permissions from capability files and permission directories (including wildcard support for plugin prefixes), and \ls\ to list available permissions from the generated ACL manifests with optional plugin and identifier filtering.

crates/tauri-cli/src/acl/permission · high confidence

New CLI commands to scaffold and initialize Android and iOS projects for Tauri plugins

The Tauri CLI now includes dedicated \plugin android init\ and \plugin ios init\ subcommands, allowing developers to add native mobile scaffolding to an existing Tauri plugin project. These commands generate the necessary Android and iOS project structures, configure the appropriate build dependencies (such as \tauri-build\), and provide the specific initialization code required for \src/lib.rs\ to register the plugin on each platform. Additionally, the initial plugin creation command (\plugin new\) and the general initialization command (\plugin init\) have been updated to support these mobile targets via \--android\, \--ios\, and \--mobile\ flags, and allow users to choose between Swift Package Manager and Xcode projects for iOS.

crates/tauri-cli/src/plugin · high confidence

New Docker images for cross-compilation

Added Dockerfiles and build scripts in .docker/cross to enable cross-compilation for architectures such as aarch64, armv7, and others. The setup installs necessary toolchains, QEMU for emulation, and a custom runner to execute cross-compiled binaries within the container environment.

.docker · high confidence

New File Associations example application

A new example application has been added to demonstrate how to associate the app with specific file types (PNG, JPG, JPEG, GIF, and custom extensions like .taurid and .taurijson). The example includes a simple UI that displays a list of opened files and provides instructions for building the Rust backend with the necessary protocol-asset feature.

examples/file-associations · high confidence

New JavaScript/TypeScript menu API implementation

The menu module in \packages/api/src/menu\ has been rewritten to provide a new JavaScript/TypeScript API for creating and managing application menus. This change introduces new classes for \Menu\, \Submenu\, \MenuItem\, \CheckMenuItem\, \IconMenuItem\, and \PredefinedMenuItem\, replacing the previous implementation. The new API supports creating menu items with icons (including native icons on macOS and custom images), predefined items like 'Bring All to Front' and 'About' (with customizable metadata), and action handlers. It also handles the transformation of image assets for icons and manages the lifecycle of menu items via resource IDs, ensuring proper integration with the underlying Rust backend.

packages/api/src/menu · high confidence

New NSIS installer templates and file association support

The NSIS bundler now ships with a complete set of installer templates, including a new \FileAssociation.nsh\ script that allows applications to register file type associations in the Windows registry. The installer template (\installer.nsi\) has been updated to support DPI awareness, custom header/sidebar images, and uninstaller icons, while the utility scripts (\utils.nsh\) now include macros for managing AppUserModelId shortcuts and using the Windows Restart Manager to handle running applications during installation.

crates/tauri-bundler/src/bundle/windows/nsis · high confidence

New Node.js bindings for Tauri CLI execution

The CLI package now exposes a new Rust library entry point (\lib.rs\) that provides Node.js bindings via NAPI. This allows Node.js consumers to invoke the Tauri CLI programmatically through a \run\ function, which executes the CLI in a separate thread to prevent blocking the Node.js event loop and communicates results back via a thread-safe callback. A companion \log\_error\ function is also exposed to allow Node.js code to capture CLI error logs.

packages/cli/src · high confidence

New Rust interface implementation for Tauri CLI

The CLI now includes a new Rust interface implementation located in \crates/tauri-cli/src/interface/rust\. This adds support for parsing Cargo configuration files (including \.cargo/config\ and \.toml\ variants) to resolve build targets, manages \Cargo.toml\ manifest features and dependencies, detects installed Rust targets via \rustc\, and handles the execution of the development server with improved stderr handling and exit reason detection.

crates/tauri-cli/src/interface/rust · high confidence

New Tauri v2 JavaScript/TypeScript API surface

The \packages/api/src\ directory now contains the complete v2 frontend API implementation, replacing the previous structure. This introduces a modular package with dedicated modules for application metadata (\app\), IPC and channels (\core\), DPI scaling (\dpi\), events (\event\), image handling (\image\), menus (\menu\), path resolution (\path\), tray icons (\tray\), and window/webview management (\window\, \webview\, \webviewWindow\). Key behavioral changes include a new \Channel\ class for streaming messages from Rust, a \SERIALIZE\_TO\_IPC\FN\ symbol for custom type serialization, and a \JsImage\ type for passing images to the backend. The \mocks\ module provides \mockIPC\ and \mockConvertFileSrc\ for testing without a backend, and the \global.d.ts\ file exposes the \window.\\TAURI\\_\ global for vanilla JS usage.

packages/api/src · high confidence

New builder API for menus and menu items

The \crates/tauri/src/menu/builders\ module introduces a new fluent builder API for constructing menus, submenus, and menu items. This includes \MenuBuilder\ and \SubmenuBuilder\ (which now supports setting icons via \submenu\_icon\ and \submenu\_native\_icon\), as well as dedicated builders for standard items (\MenuItemBuilder\), checkable items (\CheckMenuItemBuilder\), and icon items (\IconMenuItemBuilder\). This provides a more structured way to define menu structures and item properties in Rust.

crates/tauri/src/menu/builders · high confidence

New dedicated CLI commands for generating and signing updater keys

The Tauri CLI now includes a dedicated \signer\ subcommand with two new capabilities: \signer generate\ creates new signing keypairs (with options to save to files or output to console, and a warning for password-less keys in CI environments), and \signer sign\ signs arbitrary files using a private key (provided via string or file path, or environment variables like \TAURI\_SIGNING\_PRIVATE\_KEY\ and \TAURI\_SIGNING\_PRIVATE\_KEY\_PATH\). The signing command also supports binding signatures to a specific app version via \--app-version\ to ensure updater integrity, and includes backward compatibility warnings for deprecated environment variables (\TAURI\_PRIVATE\_KEY\, etc.).

crates/tauri-cli/src/signer · high confidence

New drag behavior example with QA test suite

Added a new \examples/drag\ example that demonstrates \data-tauri-drag-region\ attribute behaviors, including bare, deep, and false values, as well as interactions with clickable elements like buttons and inputs. The example includes a comprehensive HTML-based QA test suite to verify drag region handling across various UI scenarios.

examples/drag · high confidence

New end-to-end test suite for @tauri-apps/api

This change introduces a new WebdriverIO-based end-to-end testing suite for the \@tauri-apps/api\ package, located in \packages/api-e2e\. The suite exercises the API against a real Tauri application (\examples/api\) rather than using mocked backends, ensuring validation across desktop (Linux, macOS, Windows) and mobile (Android, iOS) platforms. It configures platform-specific drivers—using \@crabnebula/tauri-driver\ on desktop and Appium (UiAutomator2/XCUITest) on mobile—and includes configuration files (\wdio.conf.ts\, \wdio.android.conf.ts\, \wdio.ios.conf.ts\) and a \tauri.e2e.conf.json\ to enable the necessary \automation\ feature for testing.

packages/api-e2e · high confidence

New example demonstrating \`App::run\_return\` for post-exit logic

The \examples/run-return\ directory now provides a concrete example of using the \App::run\_return\ method. This example shows how to capture the application's exit code and execute custom logic (such as printing a message) after the event loop terminates, before explicitly calling \std::process::exit\. The example configuration has been updated to use the current schema structure.

examples/run-return · high confidence

New file-associations example app for Tauri

This change introduces a new example application demonstrating how to handle file associations and URL schemes in Tauri. The example configures the app to register specific file extensions (png, jpg, jpeg, gif, taurijson, taurid) with associated MIME types and ranks, and sets up URL scheme handlers (myapp, myscheme) via the macOS Info.plist. The Rust backend parses command-line arguments on Windows/Linux and listens for the RunEvent::Opened event on macOS/iOS/Android to receive opened file paths, which are then passed to the frontend via an initialization script. It also demonstrates security scope handling by allowing access to opened files via the asset protocol scope.

examples/file-associations/src-tauri · high confidence

New iOS mobile commands (dev, build, run) and project generation

The Tauri CLI now includes dedicated commands for iOS development and distribution. Users can run \tauri ios dev\ for development with hot-reloading, \tauri ios build\ to generate release IPAs (with options to skip code signing via \--no-sign\ or archive only via \--archive-only\), and \tauri ios run\ for production-style execution. The CLI also handles iOS project generation (\tauri ios init\), ensuring Rust targets are installed and CocoaPods dependencies are resolved. These commands support custom configuration merging, cargo features, and device selection.

crates/tauri-cli/src/mobile/ios · high confidence

New image plugin for managing image resources

A new \image\ plugin has been added to Tauri, exposing commands to create, inspect, and retrieve image data. Users can now create images from raw RGBA buffers (\new\), load them from bytes or file paths (\from\_bytes\, \from\_path\), and query their dimensions or raw pixel data (\size\, \rgba\). These images are managed as resources within the webview's resource table, allowing for efficient handling of image assets in the application.

crates/tauri/src/image · high confidence

New internal benchmarking infrastructure for CI metrics

The \bench/src\ directory now contains the core Rust binaries and utilities that power the project's internal performance benchmarking on CI. This includes \build\_benchmark\_jsons.rs\ for aggregating and storing benchmark results, \run\_benchmark.rs\ for executing specific performance tests (such as binary size, memory usage via \mprof\, and syscall counts via \strace\), and \utils.rs\ providing shared helpers for path resolution, command execution, and data parsing. These changes establish the foundational tooling for tracking Tauri's internal metrics over time.

bench/src · high confidence

New macOS signing and notarization crate

A new \tauri-macos-sign\ crate has been introduced to handle macOS code signing and notarization workflows. It provides capabilities to generate self-signed certificates, manage temporary keychains for importing signing identities, and handle provisioning profiles. The crate also integrates with Apple's \notarytool\ to submit applications for notarization, supporting both waiting for completion and asynchronous submission modes.

crates/tauri-macos-sign/src · high confidence

New macOS signing identity listing capability

The \tauri-macos-sign\ crate now includes a new \identity.rs\ module that provides functionality to list available macOS signing identities (such as iOS Distribution, Apple Development, and Developer ID Application certificates) from the system keychain. This change introduces a \Team\ struct and a \list\ function that parses X.509 certificates to extract team names, certificate identifiers, and common names, enabling the signing process to automatically discover and select appropriate signing credentials.

crates/tauri-macos-sign/src/keychain · high confidence

New mobile build utilities and plugin configuration helpers

The \tauri-plugin\ crate now includes a \build\ module with mobile-specific utilities. On macOS hosts, developers can use \mobile::update\_entitlements\ to patch iOS entitlements (e.g., for push notifications) and \mobile::update\_info\_plist\ to modify the iOS \Info.plist\ (e.g., for usage descriptions) during the build process. Additionally, \mobile::update\_android\_manifest\ allows inserting XML content into the Android manifest. The module also provides a \Builder\ to configure plugin builds (including Android/iOS paths and global API scripts) and a \plugin\_config\ helper to read plugin settings from environment variables passed by the Tauri CLI.

crates/tauri-plugin/src/build · high confidence

New tauri-schema-generator crate for JSON schema generation

A new crate, tauri-schema-generator, has been added to the repository to generate JSON schemas for Tauri configuration files. This component includes a build script that automatically produces schema files for capabilities, permissions, scopes, and the main Tauri config, ensuring that the CLI's config.schema.json is kept in sync with the current Tauri version.

crates/tauri-schema-generator · high confidence

New window enable/disable and centering APIs

This change introduces platform-specific implementations for the \WindowExt\ trait in the Wry runtime, adding \set\_enabled\ and \is\_enabled\ methods to control window interactivity, and a \center\ method to reposition windows to the center of their monitor. On Linux, enabling/disabling uses GTK sensitivity; on macOS, it toggles a semi-transparent overlay sheet; and on Windows, it uses the native \EnableWindow\ API. The \center\ logic is also implemented across platforms, with Windows handling title bar height adjustments for accurate positioning.

crates/tauri-runtime-wry/src/window · high confidence

New window management plugin and API surface

This change introduces the core window management plugin and its associated Rust types, exposing a comprehensive set of commands for creating, configuring, and manipulating application windows from JavaScript. The diff adds the \Monitor\ descriptor and a \WindowBuilder\ (behind an unstable feature flag) for programmatic window creation, alongside a plugin module that registers IPC commands for window lifecycle (create, close, destroy), state queries (is\_focused, is\_visible, is\_enabled, is\_fullscreen), and property setters (set\_title, set\_size, set\_position, set\_theme, set\_effects, set\_badge\_count). It also includes platform-specific capabilities such as macOS simple fullscreen, Windows overlay icons, and badge labels, effectively establishing the public API surface for window control in this release.

crates/tauri/src/window · high confidence

Repository initialization with core configuration and documentation files

The repository has been initialized with essential configuration and documentation files to establish the project structure. This includes an \.editorconfig\ for consistent code formatting, a \.gitignore\ covering standard build artifacts and IDE files, and \.prettierrc\/\.prettierignore\ for JavaScript/TypeScript formatting rules. Documentation is provided via \README.md\, \ARCHITECTURE.md\, and \SECURITY.md\, while licensing is clarified with \LICENSE-MIT\ and \LICENSE-APACHE-2.0\. Automation and dependency management are configured through \renovate.json\, \dependabot.yml\, and \pnpm-workspace.yaml\, and the project metadata adheres to the \publiccode.yml\ standard.

(repo-wide) · high confidence

Support for platform-specific configuration files

Tauri now supports platform-specific configuration files (e.g., \tauri.macos.conf.json\, \Tauri.windows.toml\) that are automatically merged with the main configuration file using JSON Merge Patch (RFC 7396). This allows developers to override settings for specific targets like macOS, Windows, Linux, Android, or iOS without duplicating the entire configuration structure.

crates/tauri-utils/src/config · high confidence

Security

Security fix for IPC channel data isolation

The \crates/tauri\ crate now scopes IPC channel data to the specific webview that created it, preventing other webviews from reading queued channel payloads or large invoke responses. This addresses a security vulnerability where cross-origin webviews could access data intended for a different context, and ensures these entries are purged when the owning webview is closed.

crates/tauri · high confidence

Architecture

New internal event system implementation and specification

The event handling subsystem in \crates/tauri/src/event\ has been restructured with a new internal implementation. This includes a formal specification (\event-system-spec.md\) defining emitters (App, Window, Webview, etc.) and listener types, a new \EventName\ type that validates event names against a strict character set (alphanumeric, \-\, \/\, \:\, \\_), and a refactored \Listeners\ manager that handles Rust-side listener lifecycle and pending action queues. The JavaScript bridge (\init.js\) now exposes internal unlisten capabilities, and the plugin layer (\plugin.rs\) registers the core \listen\, \unlisten\, \emit\, and \emit\_to\` commands to coordinate these changes.

crates/tauri/src/event · high confidence

Restructure webview module into dedicated subdirectory

The webview implementation has been reorganized from the crate root into a dedicated \crates/tauri/src/webview/\ directory. This change introduces a new module structure containing \mod.rs\ (core types and re-exports), \plugin.rs\ (JS-exposed commands for window management), and \webview\_window.rs\ (the \WebviewWindow\ and \WebviewWindowBuilder\ implementations). For users, this is a structural refactor that maintains the existing public API surface while improving code organization; no functional behavior or public interfaces are changed by this move.

crates/tauri/src/webview · high confidence

Restructured CLI helper modules for improved organization

The \tauri-cli\ helper logic has been reorganized into a dedicated \helpers\ module, splitting functionality into distinct files such as \app\_paths.rs\ for directory resolution, \cargo.rs\ for dependency management, \config.rs\ for configuration merging, and \framework.rs\ for frontend framework detection. This change improves code maintainability and separation of concerns without altering the external behavior of the CLI tools.

crates/tauri-cli/src/helpers · high confidence

Restructured Tauri CLI source code into modular command files

The Tauri CLI source code has been reorganized from a monolithic structure into distinct modules for each command (add, build, bundle, completions, dev, error, icon, init, inspect, remove, etc.). This change improves code maintainability and readability by separating concerns, making it easier to locate and modify specific command logic without navigating a large single file.

crates/tauri-cli/src · high confidence

Restructured internal manager modules for cleaner architecture

The internal application manager has been reorganized into dedicated sub-modules (menu, tray, webview, window) within the manager crate. This change improves code maintainability and separation of concerns by isolating the logic for managing menus, tray icons, webviews, and windows into their own files, without altering the public API or user-facing behavior.

crates/tauri/src/manager · high confidence

Restructured protocol handlers into a dedicated module

The custom protocol handling logic has been reorganized into a new \crates/tauri/src/protocol\ module, separating concerns into distinct files: \asset.rs\ for static asset serving, \tauri.rs\ for the main application URL handling and mobile dev proxying, and \isolation.rs\ for the isolation scheme. This change introduces asynchronous file loading for assets, supports multi-range HTTP requests, and implements specific mobile development features such as HTTPS scheme support on Windows and Android, custom root certificate handling, and response caching for the dev server proxy.

crates/tauri/src/protocol · high confidence

Restructured tauri-build crate with new permission and manifest logic

The \tauri-build\ crate has been reorganized into a new directory structure (\crates/tauri-build/src\), introducing dedicated modules for Access Control List (ACL) handling (\acl.rs\), dependency manifest validation (\manifest.rs\), and mobile build generation (\mobile.rs\). This restructuring adds the ability to define inlined plugins with autogenerated permissions, validates that \tauri\ and \tauri-build\ dependency features in \Cargo.toml\ match the configuration, and updates Android manifest generation to support file associations. Existing functionality like Windows VC runtime linking has been moved and slightly refactored within this new layout.

crates/tauri-build/src · high confidence

Behavioural changes

7 commits (3 fixes) modifying examples/.icons

A change to existing behaviour in examples/.icons — 7 commits (3 fixs), 19 files.

examples/.icons · medium confidence · unverified

8 commits (3 fixes) modifying crates/tauri-cli/templates/app/src-tauri

A change to existing behaviour in crates/tauri-cli/templates/app/src-tauri — 8 commits (3 fixs), 4 files: “fix: downgrade MSRV to 1.77.2 to support Windows 7 (\#11205)”; “feat: bump MSRV to 1.90 (\#13221)”; “fix(cli): Fix crate type (\#11080)”; and 5 more (refs \#11205, \#13221, \#11080, \#16029, \#10796, …).

crates/tauri-cli/templates/app/src-tauri · medium confidence · unverified

9 commits (4 fixes) modifying crates/tauri-cli/templates/plugin

A change to existing behaviour in crates/tauri-cli/templates/plugin — 9 commits (4 fixs), 6 files: “fix: downgrade MSRV to 1.77.2 to support Windows 7 (\#11205)”; “fix: the exclude path in file Cargo.toml of plugin template generated by cli (\#11914)”; “feat: bump MSRV to 1.90 (\#13221)”; and 6 more (refs \#11205, \#11914, \#13221, \#16029, \#10796, …).

crates/tauri-cli/templates/plugin · medium confidence · unverified

API example app migrated to Svelte 5 with dynamic theming

The API example application has been rewritten in Svelte 5, introducing a modern UI that supports dynamic theme switching (light, dark, and auto) via the \setTheme\ API and respects system preferences. The app now features a responsive layout with a collapsible sidebar for mobile devices, a resizable console for viewing IPC messages, and dedicated views for demonstrating Window, Menu, Tray, and WebRTC capabilities.

examples/api/src · high confidence

API example app rewritten in Svelte 5

The API example application has been completely rewritten using Svelte 5, replacing the previous implementation. This update introduces Svelte 5's new component model, including the use of \$props()\ for reactive props, \$state()\ for reactive state, and \$derived()\ for computed values. The UI now leverages Svelte 5's syntax for reactivity and lifecycle management, providing a modernized developer experience and demonstrating the framework's latest capabilities within the Tauri ecosystem.

examples/api/src/views · high confidence

API example migrated to Svelte with new permission and isolation setup

The API example application has been rebuilt using Svelte and Vite, replacing the previous framework. This update introduces a comprehensive permission model using the new \capabilities\ system (with \main.json\ and \run-app.json\ defining granular access for core, window, and webview APIs) and a sample plugin (\tauri-plugin-sample\) demonstrating scoped permissions and cross-platform glue code. Additionally, the example now configures the Isolation Pattern for enhanced security, sets up mobile-specific configurations (including an \Info.plist\ for iOS), and includes a cross-compilation setup script for Linux.

examples/api · high confidence

API example restructured with new Rust backend and plugin architecture

The \examples/api/src-tauri\ directory has been completely rewritten to demonstrate modern Tauri patterns. The Rust backend now uses a modular structure with separate files for commands (\cmd.rs\), the application entry point (\lib.rs\), and platform-specific features like system tray (\tray.rs\) and custom menu handling (\menu\_plugin.rs\). Key behavioral changes include the introduction of a custom \tauri\_plugin\_sample\ for demonstrating plugin state and channel communication, explicit permission scoping via \CommandScope\ in the \log\_operation\ command, and the use of \WebviewWindowBuilder\ for advanced window configuration (such as handling new window requests and document title changes). The example also showcases runtime system tray creation with dynamic menu switching and icon updates, replacing the previous implementation.

examples/api/src-tauri · high confidence

Added NSIS bundle target and refactored config parsing infrastructure

Users can now specify the NSIS installer format as a valid bundle target in their configuration, enabling the generation of Windows installers via NSIS. This change also introduces a new configuration parsing module (\config\_v1/parse.rs\) that handles JSON, JSON5, and TOML formats with platform-specific file support, and refactors the internal schema generation logic to use a custom \Merge\ trait for better metadata handling.

_crates/tauri-utils/src/config\v1 · high confidence

Android lifecycle hooks now delegate to the plugin manager

The generated TauriActivity for Android now forwards standard activity lifecycle events (onRestart, onResume, onPause, onStop, onDestroy, onNewIntent, and onConfigurationChanged) to the PluginManager. This ensures that Android plugins receive these lifecycle callbacks, enabling proper state management and behavior for plugins running within the Tauri Android application.

crates/tauri/mobile/android · high confidence

AppImage bundler refactored to use bundled linuxdeploy plugins

The AppImage bundling logic in \crates/tauri-bundler/src/bundle/linux/appimage\ has been restructured to inline the \linuxdeploy-plugin-gtk\ and \linuxdeploy-plugin-gstreamer\ scripts directly into the Rust crate. This change replaces external plugin dependencies with self-contained shell scripts that handle GTK and GStreamer resource bundling, ensuring the bundler works reliably without requiring pre-installed linuxdeploy plugins on the host system.

crates/tauri-bundler/src/bundle/linux/appimage · high confidence

Automated migration from Tauri v1 to v2

The \tauri migrate\ command now automatically upgrades projects from Tauri v1 to v2. This process updates the \Cargo.toml\ manifest to use v2 dependencies and features, migrates the \tauri.conf.json\ configuration to the new schema, and rewrites frontend JavaScript/TypeScript imports to use the new pluginified module structure (e.g., \@tauri-apps/api/fs\ becomes \@tauri-apps/plugin-fs\). It also handles the installation of new npm packages and the removal of obsolete ones, while ensuring that capability permissions are correctly migrated.

crates/tauri-cli/src/migrate · high confidence

Bundler logic migrated to crates/tauri-bundler with platform detection and settings restructuring

The bundling implementation has been moved from \tooling/bundler\ to \crates/tauri-bundler\, introducing new modules for platform target detection (\platform.rs\), package type definitions (\settings.rs\), and updater bundling (\updater\_bundle.rs\). This change adds runtime detection of the target architecture using \rustc --print cfg\ with a compile-time fallback, defines the full set of supported package types (deb, rpm, appimage, msi, nsis, dmg, updater, etc.) with build priorities, and implements logic to package updates as tar.gz or zip archives for macOS, Linux, and Windows. Additionally, the \AppCategory\ mapping was renamed from \gnome\_desktop\_categories\ to \freedesktop\_categories\ to align with the Freedesktop menu specification.

crates/tauri-bundler/src/bundle · high confidence

Command example updated to support rename attributes and snake\_case naming conventions

The commands example now demonstrates the new \rename\ and \rename\_all\ attributes on the \\#\[command\]\ macro, allowing developers to customize the exposed command names (e.g., using \snake\_case\ or specific aliases like \renamed\_command\_in\_mod\). The example code has been refactored to use these new naming features, and the accompanying HTML interface has been updated to invoke the newly named commands. Additionally, the example's configuration schema has been migrated to the new \tauri-config-schema\ location, and the frontend code now handles \ArrayBuffer\ responses from IPC calls.

examples/commands · high confidence

Comprehensive restructuring of the \`tauri info\` diagnostic output

The \tauri info\ command has been completely rewritten to provide a more structured and detailed diagnostic report. The new implementation organizes output into distinct sections: it now detects the build type (bundle vs. build) and displays the Content Security Policy (CSP) setting; it infers the frontend framework and bundler from \package.json\; it checks for outdated Node.js versions against the CLI's target version; it verifies the installation and versions of Rust toolchain components (rustc, cargo, rustup); it detects Windows-specific dependencies like Visual Studio build tools and WebView2; it lists installed Node.js package managers (npm, pnpm, yarn, bun, deno) and checks for outdated Tauri NPM packages; it lists Rust dependencies (tauri, wry, tao) and checks for outdated versions; and it validates that Tauri plugins have matching major/minor versions between their Rust and NPM packages, flagging mismatches as errors.

crates/tauri-cli/src/info · high confidence

DMG bundler now skips self-signing the disk image

The macOS DMG bundling process has been updated to stop automatically code-signing the generated \.dmg\ file. This change prevents the bundler from self-signing the disk image, addressing issues where self-signed DMGs caused problems during installation or verification. Users relying on the bundler for macOS distribution will now receive unsigned DMGs, which may require manual signing or notarization steps if required by their distribution channel.

crates/tauri-bundler/src/bundle/macos/dmg · high confidence

Deterministic asset embedding and improved icon selection

The codegen now produces deterministic build output by replacing HashMaps with BTreeMaps for asset and CSP hash storage and sorting generated hashes, ensuring consistent code regardless of filesystem walk order. Additionally, when embedding ICO icons, the generator now selects the largest (and deepest) entry instead of the first, providing higher-resolution icons on Windows, and validates that image assets are strictly PNG or ICO.

crates/tauri-codegen/src · high confidence

Enhanced drag-region behavior with deep and disabled modes

The window drag script now supports three modes for the \data-tauri-drag-region\ attribute: standard (drag only on direct clicks), \deep\ (drag on any click within the element's subtree), and \false\ (explicitly disables dragging for the element and its ancestors). This allows developers to create complex interactive areas where specific child elements can either trigger window dragging or remain fully interactive without blocking the drag gesture, while also fixing macOS double-click maximization to cancel if the mouse moves.

crates/tauri/src/window/scripts · high confidence

Hello World example updated to use new configuration and API structure

The Hello World example has been refreshed to align with the latest Tauri architecture. It now uses the new \tauri.conf.json\ schema, featuring a \frontendDist\ array for specifying the frontend source and a \security.csp\ block for Content Security Policy configuration. The Rust entry point (\main.rs\) has been updated to use the modern \tauri::Builder\ pattern with \invoke\handler\, and the frontend (\index.html\) now imports the \core\ module from \window.\\TAURI\\_\ to invoke commands, reflecting the shift to the new IPC and API surface.

examples/helloworld · high confidence

Internal restructuring of the codegen module

The \tauri-build\ crate has reorganized its internal code generation logic by extracting the \CodegenContext\ builder into a new \codegen/context.rs\ module. This change moves the compile-time context generation logic into a dedicated file, improving code organization without altering the public API or build behavior for users.

crates/tauri-build/src/codegen · high confidence

Isolation pattern example now uses the core API and exposes the pattern identifier

The isolation example's distribution files have been updated to demonstrate the correct usage of the Tauri Isolation pattern. The main HTML file now imports the \invoke\ function from \window.\_\TAURI\\.core\ instead of the legacy global, ensuring compatibility with the current API surface. Additionally, a new \linked.js\ script has been added to the distribution, which logs the \\\_TAURI\PATTERN\\\ identifier from \window.\\_TAURI\INTERNALS\\_\ to verify that the isolation context is correctly established.

examples/isolation/dist · high confidence

Isolation pattern now supports binary payloads and origin validation

The Isolation pattern has been updated to handle binary IPC payloads in addition to strings, allowing applications to send non-text data securely. The JavaScript isolation script now validates that incoming messages originate from the expected frame origin, enhancing security against cross-origin injection. Additionally, the Rust backend now exposes a direct encryption method and parses a content-type field from payloads, while the JavaScript side explicitly constructs message objects with separate payload encryption, ensuring that binary data is preserved through the encryption process.

crates/tauri-utils/src/pattern · high confidence

Linux bundler now generates desktop entries with quoted Exec paths and proper icon handling

The Linux bundler now correctly generates \.desktop\ files for freedesktop-compliant environments. The \Exec\ field is automatically wrapped in quotes if the application binary name contains spaces, preventing launch failures. Additionally, the bundler now properly processes PNG icons, placing them in the standard \hicolor\ icon hierarchy based on their dimensions and density, and generates the corresponding desktop entry file with support for categories, comments, and MIME type associations.

crates/tauri-bundler/src/bundle/linux/freedesktop · high confidence

Linux bundler refactored with RPM compression support and DEB changelog generation

The Linux bundler implementation has been restructured into the \crates/tauri-bundler\ crate, introducing new capabilities for both RPM and DEB package formats. For RPM, users can now configure compression algorithms (Gzip, Zstd, Xz, Bzip2) and the system adds support for \recommends\, \provides\, \conflicts\, and \obsoletes\ dependency fields, while also ensuring empty release values default to \1\. For DEB packages, the bundler now generates a compressed changelog file from a user-sourced path, utilizes a shared \freedesktop\ module for icon and desktop file generation, and correctly handles resource file mapping. The refactoring also expands architecture support to include RISC-V 64-bit and improves error context for file operations.

crates/tauri-bundler/src/bundle/linux · high confidence

The Windows MSI bundler now uses a new template structure in \crates/tauri-bundler/src/bundle/windows/msi\, introducing a \default-locale-strings.xml\ for translatable UI strings and a \languages.json\ mapping locale codes to language IDs. The installer template (\main.wxs\) has been updated to support deep-link protocols via registry entries and file associations, adds homepage metadata to the Windows Control Panel app entry, and improves installation directory detection by prioritizing the MSI-specific registry key over the NSIS default. Additionally, the template now supports ARM64 builds and includes new PowerShell tasks for handling elevated update and uninstall operations.

crates/tauri-bundler/src/bundle/windows/msi · high confidence

The menu implementation has been restructured into distinct modules for different item types, introducing dedicated \CheckMenuItem\ and \IconMenuItem\ types alongside the existing \MenuItem\ and \Submenu\. This change adds the ability to display icons on submenus and icon menu items, supports native icons on macOS, and includes a new \BringAllToFront\ predefined menu item. The refactoring also ensures proper cleanup of menu channels to prevent resource leaks and fixes issues with submenu creation via object arguments.

crates/tauri/src/menu · high confidence

Multi-window example updated to new API and config schema

The multiwindow example has been migrated to the new Tauri configuration schema, moving settings from the \tauri\ and \package\ sections into \app\ and \bundle\, and replacing \distDir\/\devPath\ with \frontendDist\. The Rust code now uses \WebviewWindowBuilder\ instead of the deprecated \WindowBuilder\, and the frontend JavaScript has been updated to use the new \window.\_\TAURI\\.webviewWindow\ and \window.\\TAURI\\_.event\ APIs for creating windows and emitting messages. Additionally, the example now supports tabbing identifiers for macOS windows and includes explicit command allowances for event and webview window creation.

examples/multiwindow · high confidence

New ACL system for fine-grained permission control

Tauri introduces a new Access Control List (ACL) system to replace the legacy permission model, allowing developers to define precise, granular permissions for IPC commands via capability files. This change restructures the \tauri-utils\ crate with new modules for handling identifiers, manifests, and schema generation, and introduces a build-time resolution process that compiles permissions into the binary. Users will now configure access using capability definitions that map specific permissions to windows or webviews, with support for scoped arguments and JSON5 configuration files.

crates/tauri-utils/src/acl · high confidence

New filesystem and HTTP utility modules for bundler tools

The bundler now includes dedicated \fs\_utils\ and \http\_utils\ modules to handle file operations and tool downloads. The HTTP utilities ensure that requests to fetch build tools include a proper User-Agent header and support GitHub mirror redirection via environment variables, improving reliability in restricted network environments. Additionally, the HTTP module introduces a \platform-certs\ feature flag that allows the bundler to use the system's root certificates for TLS verification, enhancing security and compatibility on systems with custom CA setups.

crates/tauri-bundler/src/utils · high confidence

New macOS bundler implementation with code signing and notarization

The macOS bundling logic in \crates/tauri-bundler/src/bundle/macos\ has been replaced with a new implementation that constructs \.app\ bundles, generates \Info.plist\ and icon files, and handles code signing and notarization. This change introduces support for custom \CFBundleVersion\ on macOS and iOS, allows skipping code signing via a \--no-sign\ flag, and adds the ability to skip the stapling step during notarization. It also supports Liquid Glass icons and includes fixes for file association metadata and unnecessary entitlements on frameworks.

crates/tauri-bundler/src/bundle/macos · high confidence

New mobile plugin infrastructure with deadlock-avoidance patterns

The \crates/tauri/src/plugin/mobile.rs\ module introduces the core glue code for handling plugin commands and channels on Android and iOS. It implements a pending-call handler system that explicitly drops mutex locks before invoking callbacks that communicate with the webview, preventing deadlocks that could occur if the UI thread blocked while holding the lock. It also provides specific JNI integration functions (\handle\_android\_plugin\_response\, \send\_channel\_data\) to bridge Rust and Kotlin, and includes an iOS plugin registration path that waits for the native side to initialize before returning.

crates/tauri/src/plugin · high confidence

New resource management plugin with fallback close behavior

A new \resources\ plugin has been added to expose resource management capabilities to the application. This includes a \close\ command that attempts to close a resource by its ID, specifically implementing a fallback mechanism that checks the Webview, Window, and AppHandle resource tables in sequence if the initial close attempt fails. This ensures resources can be properly cleaned up even if they were registered in a different scope than the one initially queried.

crates/tauri/src/resources · high confidence

Repository restructure and version updates for tauri-build and tauri-codegen

The \tauri-build\ and \tauri-codegen\ crates have been moved from \core/\ to \crates/\, with license files renamed to use dashes. Both crates now target Rust edition 2024 and require a minimum supported Rust version (MSRV) of 1.90. \tauri-build\ (v2.7.0) adds \Attributes::config\_path\ to customize the config path, introduces \WindowsAttributes::static\_vc\_runtime\ for MSVC static runtime linking, and improves build script reliability by watching resource directories and fixing capability validation and path resolution. \tauri-codegen\ (v2.7.0) adds Windows-specific image loading from embedded icon resources, ensures reproducible builds by sorting embedded assets and hashes, and selects the largest ICO entry for better icon quality. Dependencies for both crates have been updated to \tauri-utils@2.10.0\ and \tauri-codegen@2.7.0\ (for \tauri-build\), with \tauri-codegen\ also upgrading \brotli\ to v9 and \png\ to v0.18.

crates/tauri-build · high confidence

Repository restructuring and HTML parsing engine migration

The \tauri-utils\ crate has been relocated from \core/tauri-utils\ to \crates/tauri-utils\ as part of a broader repository restructure. Additionally, the HTML manipulation module has been migrated from the \kuchiki\ parser to the \dom\_query\ engine (exposed as \html2\), while the legacy \html\ module remains available via a feature flag. This change also introduces new build-time utilities for linking Apple libraries and updating the Android manifest, and refactors the \EmbeddedAssets\ implementation to use \Cow\ for more efficient asset iteration.

crates/tauri-utils/src · high confidence

Repository restructuring and macOS restart reliability fix

The Tauri core library has been reorganized from the \core/tauri\ directory to \crates/tauri\, requiring updates to import paths (e.g., \tauri::api::process\ is now \tauri::process\). On macOS, the application restart mechanism now correctly handles binary name changes during updates by reading the \Info.plist\ file to locate the executable, ensuring the app restarts reliably after code-signing or update processes modify the binary path.

crates/tauri/src · high confidence

Repository restructuring and updated project metadata

The \tauri-utils\ crate has been relocated from \core/tauri-utils\ to \crates/tauri-utils\ as part of a broader repository restructure. This move is accompanied by updates to the \README.md\, including refreshed status badges, corrected links to the crates.io package, and updated documentation references.

crates/tauri-utils · high confidence

Restructured CLI interface with new Rust app abstraction

The Tauri CLI has been restructured to introduce a new \interface\ module that abstracts platform-specific build logic. This change adds a \Rust\ struct and \AppSettings\ trait to centralize configuration handling, bundler settings, and binary discovery for Rust-based projects. Users will benefit from improved error handling, better support for custom main binary names, and more robust management of build targets and features through this new internal architecture.

crates/tauri-cli/src/interface · medium confidence

Restructured IPC module and introduced runtime ACL authority

The IPC subsystem has been reorganized into a dedicated \ipc\ module, moving core files like \command.rs\ and \format\_callback.rs\ to their new locations. This change introduces a new \RuntimeAuthority\ and \ScopeManager\ to handle Access Control List (ACL) enforcement at runtime, allowing capabilities to be added dynamically via the \CapabilityBuilder\. The \CommandItem\ now exposes resolved ACL data and plugin context, while the \Channel\ implementation has been refined to properly handle raw payloads and ensure callbacks are cleaned up when webviews close.

crates/tauri/src/ipc · high confidence

Restructured Tauri JavaScript scripts into a modular, unified bundle

The JavaScript runtime scripts have been reorganized from a single monolithic file into a modular structure (core, init, ipc, isolation, pattern, freeze\prototype, process-ipc-message-fn) and compiled into a new \bundle.global.js\. This change updates the internal API surface by moving properties like \\\_TAURI\PATTERN\\\ and the IPC handler onto \window.\\_TAURI\INTERNALS\\_\ instead of the global \window\ object, and introduces a new \SERIALIZE\_TO\_IPC\FN\ key (\\\_TAURI\_TO\_IPC\KEY\\_\) to handle complex data serialization for IPC messages. The \init.js\ script now orchestrates the loading of these individual modules, and the \ipc.js\ script has been updated to use the new internal namespace and serialization logic.

crates/tauri/scripts · high confidence

Restructured filesystem scope implementation and API

The filesystem scope logic has been moved into a dedicated \fs\ module and re-implemented to improve pattern handling and reliability. This change introduces a new \Scope::is\_forbidden\ capability, fixes deadlocks in scope event handling, and resolves issues with canonicalizing root paths on Windows. Users can now manage asset protocol scopes via the \Scopes\ manager API, which exposes methods to allow or forbid specific files and directories at runtime.

crates/tauri/src/scope · high confidence

Restructured path resolution into platform-specific modules with new Android support

The path resolution logic has been reorganized into separate platform-specific implementations: a new \android.rs\ module for Android devices and a \desktop.rs\ module for desktop platforms (Linux, macOS, Windows). This change introduces Android-specific path resolution via a mobile plugin, including support for resolving file names from Android content URIs in the \file\_name\ method. It also corrects the \video\_dir\ behavior on Android to point to the app-specific Movies directory instead of the external cache storage, requiring users to migrate any files previously stored in the cache location. Additionally, the \SafePathBuf\ type now derives \serde::Serialize\ and implements \FromStr\, and the \PathResolver\ is now \Clone\.

crates/tauri/src/path · high confidence

Restructured repository layout and added iOS plugin templates

The repository has been reorganized, moving CLI scripts and core scripts to new locations under \crates/tauri-cli\ and \crates/tauri\. Additionally, new template files have been added to support iOS plugin development via Swift Package Manager, including Swift source code, tests, and configuration files, alongside a guest JavaScript template for invoking plugin commands.

(repo-wide) · high confidence

Reworked macro implementation and mobile entry point support

The \tauri-macros\ crate has been restructured to support new capabilities and improved stability. The \mobile\_entry\_point\ macro now supports \async\ functions, automatically wrapping them to block on the async runtime for mobile targets. A new \context.rs\ module handles the \generate\_context!\ macro, parsing configuration, capabilities, and assets to embed them into the binary. The \menu.rs\ module introduces a refined \DoMenuItemInput\ parser for handling menu item kinds with negation support, addressing previous panics in menu-related commands. Additionally, the \runtime.rs\ module provides a \default\_runtime\ attribute to set default generic parameters for runtime types based on feature flags.

crates/tauri-macros/src · high confidence

Runtime binary patching for bundle type detection

The bundler now embeds bundle type information directly into the main binary at build time by patching a placeholder token with the specific package type (e.g., NSIS, MSI, AppImage, Deb, RPM). This allows the application to detect its own bundle type at runtime, which is required for the updater plugin to correctly identify and update the package. The process is controlled by the \binary\_patching\ setting (defaulting to enabled), and on Windows, the main binary is re-signed after patching to ensure code signature verification passes.

crates/tauri-bundler/src · high confidence

Runtime restructure and expanded window/monitor APIs

The \tauri-runtime\ crate has been restructured from \core/tauri-runtime\ to \crates/tauri-runtime\, introducing new modules for DPI handling (\dpi.rs\) and webview permissions (\webview\_permissions.rs\). This change exposes a comprehensive set of window and webview capabilities, including monitor work area access, window focus and enablement controls, webview reloading, cookie management, and extension support. It also adds granular permission handling for features like microphone, camera, and file system access, alongside new event handlers for document title changes and new window requests.

crates/tauri-runtime/src · high confidence

Splashscreen example simplified and migrated to new configuration schema

The splashscreen example has been significantly refactored to align with the updated Tauri configuration structure and API. The \tauri.conf.json\ file now uses the new schema location and top-level keys (e.g., \app\, \bundle\), replacing the previous nested structure. In the Rust code, the complex dual-mode implementation (Rust-init vs. UI-init) has been removed in favor of a single, simpler approach using \AppHandle\ to manage window visibility. This change removes the need for manual state management of windows via \Arc\<Mutex\<\>\>\ and simplifies the command handler to directly interact with webview windows.

examples/splashscreen · high confidence

Streaming example updated to use new Tauri configuration schema and core API

The streaming example has been refactored to align with Tauri's updated configuration structure and API surface. The \tauri.conf.json\ file now uses the new schema (referencing \config.schema.json\), moving settings like \productName\ and \identifier\ to the top level, restructuring \build\ to use \frontendDist\, and updating \security\ to include an \assetProtocol\ scope. In the frontend (\index.html\), the code now imports \invoke\ and \convertFileSrc\ from \window.\_\TAURI\\_.core\ instead of the legacy \tauri\ namespace, and the video source path has been updated to match the new asset scope. The Rust backend (\main.rs\) has been simplified and modernized to use the \http\ crate for handling range requests and \getrandom\ for boundary generation, while the README now clarifies that Tauri has a built-in \asset\ protocol for this functionality.

examples/streaming · high confidence

Tauri API package restructured with new build and configuration files

The \packages/api\ directory has been restructured to support the current build process. A new \rollup.config.ts\ is now used to bundle the TypeScript sources into ESM, CJS, and IIFE formats, including a script bundle for the Tauri core. The \tsconfig.json\ has been updated to target ES2019, use the 'bundler' module resolution, and enable strict type checking. Additionally, an \eslint.config.js\ is introduced to enforce code quality and security rules, and a \.gitignore\ file is added to exclude the \/dist/\ build output.

packages/api · high confidence

Tauri CLI 2.12.0 release with security hardening and new bundler options

This release introduces several new capabilities and security improvements for the Tauri CLI. Users can now bundle the Visual C++ runtime with Windows installers, control static runtime linking, and skip binary patching during builds. The \tauri icon\ command supports non-square images, and the bundler now reports bundle sizes. Security is strengthened by rejecting invalid Host headers in the dev server, securing the mobile dev server with per-session tokens, preventing npm package squatting during plugin installation, and ensuring private keys are created with restrictive permissions. Additionally, the CLI now warns when the default \productName\ is used, improves Android/Gradle compatibility, and fixes various bugs in mobile builds and configuration handling.

crates/tauri-cli · high confidence

Tauri CLI v2.12.0 release with security hardening and platform updates

The Tauri CLI has been updated to version 2.12.0, introducing significant security improvements and platform-specific enhancements. Security-wise, the CLI now prevents DNS rebinding attacks by validating the Host header on the dev server, secures mobile build scripts with per-session tokens and restricted file permissions, and stops \tauri add\ from automatically installing potentially unsafe community plugin API packages. Functionally, the release adds support for copying Visual C++ runtime DLLs to Windows installers, allows non-square images in the icon generator, and enables binding updater signatures to specific app versions. It also updates Android templates to Kotlin 2.x and Gradle 9.6.1, and improves \tauri init\ to run non-interactively in CI environments.

packages/cli · high confidence

Tauri Runtime v2.12.0 introduces navigation limits, permission APIs, and monitor-specific fullscreen

The \tauri-runtime\ crate has been updated to version 2.12.0, bringing several new capabilities and breaking changes. Users can now restrict webview navigation to app-bound domains via \limit\_navigations\_to\_app\_bound\_domains\ and control macOS app activation behavior with \activate\_ignoring\_other\_apps\. A new \no\_redirection\_bitmap\ option is available for Windows windows, and the \wry\ permission handler API is exposed, supporting permissions like DisplayCapture, Midi, and LocalFonts. Additionally, windows can now be set to fullscreen on a specific monitor using \set\_fullscreen\_on\_monitor\. This release also includes a breaking change where \RuntimeHandle\ methods for monitor queries (\primary\_monitor\, \monitor\_from\_point\, \available\_monitors\) now return \Result\s. Under the hood, the crate has moved to Rust edition 2024, updated \objc2\ dependencies on macOS, and dropped Windows 7 support by updating \windows\ and \webview2-com\ libraries.

crates/tauri-runtime · high confidence

Tray icon API restructured with tagged events and new configuration options

The tray icon module has been reorganized into \mod.rs\ and \plugin.rs\, introducing a tagged \TrayIconEvent\ enum (serialized with a \type\ field) that distinguishes between Click, DoubleClick, Enter, Move, and Leave events, replacing the previous untagged structure. The JavaScript API now supports configuring \showMenuOnLeftClick\ and \iconAsTemplate\ options during tray creation, and exposes commands to manage tray icons by ID (get, remove) and update their icon, menu, tooltip, title, and visibility dynamically.

crates/tauri/src/tray · high confidence

Update isolation hook signature and format example files

The \isolation-dist\ example now passes an \options\ argument to the \\_\_TAURI\_ISOLATION\HOOK\\_\ function, updating the hook signature to support additional configuration. Additionally, the example files have been reformatted to comply with project style guidelines, including HTML indentation and the addition of license headers to the JavaScript file.

examples/isolation/isolation-dist · high confidence

Updated Android app template with edge-to-edge display and Material 3 theming

The Android app initialization template now uses the \Theme.Material3.DayNight.NoActionBar\ parent theme for both light and dark modes, providing a modern Material Design 3 appearance. Additionally, the \MainActivity\ now calls \enableEdgeToEdge()\, ensuring the app content extends into the system bars for an immersive edge-to-edge experience on supported Android versions.

crates/tauri-cli/templates/mobile/android/app · high confidence

Updated Android plugin and mobile templates with new structure and ProGuard rules

The Android plugin template and mobile Android configuration have been restructured to include essential build artifacts and security configurations. The plugin template now provides a standard Android project layout with an AndroidManifest, example Kotlin source files for plugin commands, and corresponding unit and instrumentation tests. Additionally, the mobile Android template now includes a consumer-rules.pro file with specific ProGuard rules to preserve Tauri's JNI methods, plugin annotations, and JSON serialization classes, ensuring that minification does not break native interop.

crates/tauri-cli/templates/plugin/android · high confidence

Updated binary path caching to use ctor v1 declarative syntax

The mechanism for caching the application's starting binary path has been updated to align with the ctor crate v1 API. The code now uses the declarative \ctor!\ macro instead of the previous attribute-based approach, explicitly marking the initialization as unsafe to match the new library requirements. This change ensures compatibility with the updated dependency while maintaining the same behavior of caching the binary path before the main function executes.

crates/tauri-utils/src/platform · high confidence

Updated iOS plugin template to target iOS 15.0

The iOS Xcode project template for Tauri plugins now sets the minimum deployment target to iOS 15.0, aligning with the app template's SDK versions. This change ensures that newly generated plugin projects are compatible with modern iOS development standards and removes support for older iOS versions in the generated codebase.

crates/tauri-cli/templates/plugin/ios-xcode · high confidence

Updated plugin example templates to Rust Edition 2024 and MSRV 1.90

The plugin example templates now require Rust 1.90 and use Edition 2024, reflecting the latest stable language features. The API example template has been migrated to Svelte 5, utilizing the new \$state\ reactive syntax and updated Vite configuration, while the basic template provides a minimal vanilla JavaScript baseline. Both templates now include proper IDE extension recommendations for VS Code and updated capability schemas.

crates/tauri-cli/templates/plugin/\\example-api · high confidence

Vendor code restructured and updated for Rust compatibility

The vendored BLAKE3 reference implementation has been moved to the new crate structure and updated to resolve compiler warnings. The code now uses the stable \as\_chunks\ method instead of the deprecated \chunks\_exact\ combined with \try\_into\, ensuring cleaner compilation without altering the underlying hashing logic.

crates/tauri-codegen/src/vendor · high confidence

Windows bundler module structure and code signing implementation

The Windows bundler module has been restructured into dedicated files for module organization, NSIS/MSI output paths, and code signing logic. The new sign.rs module implements the core code signing workflow, including automatic detection of the Signtool executable via the Windows Registry and environment variables, support for custom signing commands, and verification of existing signatures. The util.rs module provides utilities for downloading WebView2 installers and locating Visual C++ runtime DLLs for bundling, while the mod.rs file establishes the public API for the Windows bundler components.

crates/tauri-bundler/src/bundle/windows · high confidence

On Windows, the runtime's error dialog implementation has been updated to support clickable hyperlinks within error messages. When the \common-controls-v6\ feature is enabled, the dialog uses the modern Task Dialog API, which allows users to click links directly in the error message to open them. If the feature is disabled, the dialog falls back to a standard message box and automatically strips hyperlink markup from the text to ensure compatibility.

crates/tauri-runtime-wry/src/dialog · high confidence

Fixes

Add KMP string search utility for bundler

The Tauri bundler now includes a Knuth–Morris–Pratt (KMP) string matching implementation in the \kmp\ module. This adds a utility function to locate patterns within byte arrays, which supports internal string replacement logic used during the bundling process.

crates/tauri-bundler/src/bundle/kmp · medium confidence

Android template now uses Gradle 9.6.1

The Android project template has been updated to use Gradle version 9.6.1. This change ensures that new Android projects generated by Tauri will utilize the latest Gradle wrapper configuration, providing access to recent build tool improvements and compatibility updates out of the box.

crates/tauri-cli/templates/mobile/android/gradle · high confidence

Improved Windows executable detection for Tauri CLI in Android builds

The Android build template now includes a Kotlin-based Gradle plugin and build task that handle invoking the Tauri CLI binary. Specifically, on Windows, the build process will automatically retry with common executable extensions (.exe, .cmd, .bat) if the initial attempt to run the Tauri binary fails, resolving issues with tools like nvm4w that may not expose the executable with a standard extension.

crates/tauri-cli/templates/mobile/android/buildSrc · high confidence

Updated iOS project template with modern build configuration and assets

The iOS project template has been updated to include a dedicated LaunchScreen storyboard, a complete set of App Icon assets for iPhone and iPad, and an ExportOptions.plist configured for debugging. The project.yml configuration now explicitly sets the initial view controller for the launch screen, enforces arm64 and Metal device capabilities, and configures build settings to exclude static libraries from resources to prevent build collisions. Additionally, workspace settings have been added to optionally support the legacy build system, and a .gitignore file has been introduced to exclude Xcode user data and build artifacts.

crates/tauri-cli/templates/mobile/ios · high confidence

Test coverage

Added ACL test fixtures and snapshots for capability resolution; Added Tauri benchmark application for file transfer testing; Added benchmark test applications for CPU-intensive and hello-world scenarios; Added benchmark test fixtures for CPU, file transfer, and hello world scenarios; Added end-to-end tests for the Tauri API surface; Added integration test for CLI project initialization and build; Added integration tests for process restart with symlinks; Added test fixture for macOS signing certificate; Added test fixtures for the Isolation security pattern; Added test for macOS app relaunch behavior; Added test utilities for unit testing Tauri applications; Added tests for iOS pbxproj handling and non-interactive init.

Dependencies

Initial workspace configuration and dependency lockfile

The repository is initialized with a Cargo workspace manifest defining the project structure, including core crates, CLI, bundler, and examples, alongside a generated Cargo.lock file that pins all Rust dependencies. The workspace sets the Rust edition to 2024 and establishes a minimum supported Rust version (MSRV) of 1.90, while also configuring workspace-level dependency management and linting rules for the entire codebase.

(dependencies) · high confidence

Vendored self-signed certificate generation from apple-codesign

The \tauri-macos-sign\ crate now includes a vendored copy of the self-signed code signing certificate generation logic from the \apple-codesign\ crate (version 0.29.0). This change removes the external dependency on \apple-codesign\, which had not been released since version 0.29.0 and was blocking dependency updates elsewhere in the Tauri project. Users benefit from unblocked dependency resolution and reduced external crate overhead, while the core functionality for generating self-signed certificates for macOS code signing remains intact.

_crates/tauri-macos-sign/src/apple\codesign · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 52 → 53 (+1.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 52 → 48 (-4.4)
  • Architecture 87 → 86 (-0.7)
  • Maturity 69 → 69 (+0.2)
  • Readiness 50 → 52 (+1.8)
  • Security 57 → 59 (+1.9)
  • Event Sourcing 100 → 100 (+0.0)
  • Accessibility 49 → 53 (+4.3)
  • Performance 60 → 100 (+40.0)

Resolved (60)

  • Duplicated block (10 lines × 2) (crates/tauri-cli/src/acl/capability/new.rs)
  • Duplicated block (10 lines × 2) (crates/tauri-cli/src/helpers/npm.rs)
  • Duplicated block (10 lines × 2) (crates/tauri-cli/src/mobile/android/project.rs)
  • Duplicated block (10 lines × 2) (crates/tauri-cli/src/plugin/android.rs)
  • Duplicated block (11 lines × 2) (crates/tauri-bundler/src/bundle/linux/debian.rs)
  • Duplicated block (11 lines × 3) (crates/tauri-cli/src/mobile/android/dev.rs)
  • Duplicated block (12 lines × 2) (crates/tauri-cli/src/mobile/android/dev.rs)
  • Duplicated block (12 lines × 2) (crates/tauri-cli/src/mobile/ios/dev.rs)
  • Duplicated block (12 lines × 2) (crates/tauri/src/ipc/authority.rs)
  • Duplicated block (13 lines × 2) (crates/tauri-bundler/src/bundle/windows/msi/mod.rs)
  • Duplicated block (13 lines × 2) (crates/tauri-cli/src/acl/capability/new.rs)
  • Duplicated block (13 lines × 2) (crates/tauri-cli/src/mobile/android/android_studio_script.rs)
  • Duplicated block (13 lines × 2) (crates/tauri-cli/src/mobile/android/run.rs)
  • Duplicated block (15 lines × 2) (crates/tauri-cli/src/mobile/android/android_studio_script.rs)
  • Duplicated block (15 lines × 4) (crates/tauri-cli/src/mobile/android/mod.rs)
  • Duplicated block (20 lines × 2) (crates/tauri-cli/src/mobile/android/mod.rs)
  • Duplicated block (25 lines × 2) (crates/tauri-utils/src/html.rs)
  • Duplicated block (5 lines × 2) (crates/tauri-cli/src/acl/capability/new.rs)
  • Duplicated block (5 lines × 2) (crates/tauri-utils/src/config.rs)
  • Duplicated block (5 lines × 2) (crates/tauri-utils/src/config.rs)
  • …and 40 more

New (122)

  • Documentation: no build, run or usage example (packages/cli/npm/darwin-arm64/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/darwin-x64/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/linux-arm-gnueabihf/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/linux-arm64-gnu/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/linux-arm64-musl/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/linux-riscv64-gnu/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/linux-x64-gnu/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/linux-x64-musl/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/win32-arm64-msvc/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/win32-ia32-msvc/README.md)
  • Documentation: no build, run or usage example (packages/cli/npm/win32-x64-msvc/README.md)
  • Duplicated block (10 lines × 2) (crates/tauri-cli/src/acl/capability/new.rs)
  • Duplicated block (10 lines × 2) (crates/tauri-cli/src/helpers/npm.rs)
  • Duplicated block (10 lines × 2) (crates/tauri-cli/src/plugin/android.rs)
  • Duplicated block (11 lines × 2) (crates/tauri-bundler/src/bundle/windows/msi/mod.rs)
  • Duplicated block (11 lines × 3) (crates/tauri-cli/src/mobile/android/dev.rs)
  • Duplicated block (12 lines × 2) (crates/tauri-cli/src/mobile/ios/dev.rs)
  • Duplicated block (12 lines × 2) (crates/tauri/src/ipc/authority.rs)
  • Duplicated block (12 lines × 2) (crates/tauri/src/ipc/channel.rs)
  • Duplicated block (13 lines × 2) (crates/tauri-bundler/src/bundle/windows/msi/mod.rs)
  • …and 102 more

Changes since last survey

  • 38 commits — 20 feature/other, 18 fixes

By area

  • (root) — 16 commits
  • .github/workflows — 3 commits
  • crates/tauri — 2 commits
  • .changes/bundler-close-main-binary-before-sign.md — 1 commit
  • .changes/bundler-msi-desktop-shortcut-upgrade.md — 1 commit
  • .changes/config-data-store-identifier.md — 1 commit
  • .changes/fix-taurignore-root.md — 1 commit
  • .changes/inline-config-parse-json.md — 1 commit
  • .changes/macos-restart-background.md — 1 commit
  • .changes/new-window-empty-url.md — 1 commit
  • .changes/nsis-exe-check-windows-only.md — 1 commit
  • .changes/release-window-id-early.md — 1 commit
  • .changes/rpm-prerelease-version.md — 1 commit
  • .changes/utils-color-parse-non-ascii.md — 1 commit
  • .changes/utils-mime-type-extension-case.md — 1 commit
  • .changes/utils-resource-path-drive-prefix.md — 1 commit
  • .changes/windows-resize-accessibility-hit-test.md — 1 commit
  • crates/tauri-build — 1 commit
  • crates/tauri-bundler — 1 commit
  • crates/tauri-cli — 1 commit

Notable commits

  • fix: ci(renovate): fix rangeStrategy
  • fix: fix(bundler): close the main binary before running the Windows sign command (#16478)
  • fix: fix(bundler): don't re-create a deleted desktop shortcut on MSI upgrade (#16506)
  • fix: fix(bundler): only check NSIS.exe on Windows (#16486)
  • fix: fix(bundler): rpm bundling fails for SemVer pre-release versions (#16336)
  • fix: fix(ci): webkit2gtk-driver is now webkitgtk-webdriver on ubuntu 26 (#16509)
  • fix: fix(ci): e2e tests on unix platforms (#16504)
  • fix: fix(ci): test core on macos latest (#16489)
  • fix: fix(cli): keep watching folders matched by .taurignore, filter entries and events (#16398)
  • fix: fix(cli): percent-decode request paths in the builtin dev server (fix #12763) (#16436)
  • fix: fix(core): don't bring the app to the front on macOS restart (#16462)
  • fix: fix(core): don't hold the webviews lock while emitting to webviews (#16438)
  • fix: fix(macos): apply dataStoreIdentifier from the window config (fix #16461) (#16464)
  • fix: fix(tauri-runtime-wry): treat an empty new window URL as about:blank (#16427)
  • fix: fix(utils): don't panic parsing a hex Color with non-ASCII characters (#16444)
  • fix: fix(utils): keep the drive prefix of absolute resource paths on Windows (#16453)
  • fix: fix(utils): match file extensions case-insensitively in MimeType (#16447)
  • fix: fix(windows): let accessibility hit tests pass through resize helper (fix #12901) (#16439)
  • change: build(deps): bump follow-redirects from 1.16.1 to 1.16.2 (#16463)
  • change: chore(deps): update dependency @rollup/plugin-terser to v1.0.2 (#16400)
  • …and 18 more

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 2 removed · edges 0 added · 1 removed

Added bounded contexts (1)

  • crates/tauri/mobile/android

Removed bounded contexts (2)

  • crates/tauri/mobile/android
  • examples/api/src-tauri/tauri-plugin-sample/android

Removed dependency edges (was a dependency, now gone) (1)

  • examples/api/src-tauri/tauri-plugin-sample/android → crates/tauri/mobile/android

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

tauri-apps/tauri was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 3aac98b498eff89a6261fd8a3cb08e019258ad7a — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.