tauri Documentation

Build smaller, faster, and more secure desktop and mobile applications with a web frontend.

110,162 stars Rust Rust 1 file · ~12,598 tokens #desktop-app#high-performance#mobile-app#native-app#rust#web-frontend#webview
RAW Doc

1. Project Overview & Quickstart (tauri-apps/tauri)

File: README.md








Introduction

Tauri is a framework for building tiny, blazingly fast binaries for all major operating systems. Developers can integrate any front-end framework that compiles to HTML, JS and CSS for building their user interface. The backend of the application is a rust-sourced binary with an API that the front-end can interact with.

The user interface in Tauri apps currently leverages tao as a window handling library on macOS, Windows, Linux, Android and iOS. To render your application, Tauri uses WRY, a library which provides a unified interface to the system webview, leveraging WKWebView on macOS & iOS, WebView2 on Windows, WebKitGTK on Linux and Android System WebView on Android.

To learn more about the details of how all of these pieces fit together, please consult this ARCHITECTURE.md document.

Getting Started

If you are interested in making a tauri app, please visit the documentation website.

The quickest way to get started is to install the prerequisites for your system and create a new project with create-tauri-app. For example with npm:

sh
npm create tauri-app@latest

Features

The list of Tauri's features includes, but is not limited to:

  • Built-in app bundler to create app bundles in formats like .app, .dmg, .deb, .rpm, .AppImage and Windows installers like .exe (via NSIS) and .msi (via WiX).
  • Built-in self updater (desktop only)
  • System tray icons
  • Native notifications
  • Native WebView Protocol (tauri doesn't create a localhost http(s) server to serve the WebView contents)
  • GitHub action for streamlined CI
  • VS Code extension

Platforms

Tauri currently supports development and distribution on the following platforms:

Platform Versions
Windows 7 and above
macOS 10.15 and above
Linux webkit2gtk 4.0 for Tauri v1 (for example Ubuntu 18.04). webkit2gtk 4.1 for Tauri v2 (for example Ubuntu 22.04).
iOS/iPadOS 9 and above
Android 7 and above (currently 8 and above)

Contributing

Before you start working on something, it's best to check if there is an existing issue first. It's also a good idea to stop by the Discord server and confirm with the team if it makes sense or if someone else is already working on it.

Please make sure to read the Contributing Guide before making a pull request.

Thank you to everyone contributing to Tauri!

Documentation

Documentation in a polyglot system is a tricky proposition. To this end, we prefer to use inline documentation in the Rust & JS source code as much as possible. Check out the hosting repository for the documentation site for further information: https://github.com/tauri-apps/tauri-docs

Partners

For the complete list of sponsors please visit our website and Open Collective.

Organization

Tauri aims to be a sustainable collective based on principles that guide sustainable free and open software communities. To this end it has become a Programme within the Commons Conservancy, and you can contribute financially via Open Collective.

Licenses

Code: (c) 2015 - Present - The Tauri Programme within The Commons Conservancy.

MIT or MIT/Apache 2.0 where applicable.

Logo: CC-BY-NC-ND

File: .devcontainer/README.md

VS Code Devcontainer for Tauri

Overview

Please note that most of these instructions are derived from Microsoft's VS Code documentation: Developing inside a Container. Check the official documentation if you encounter problems and submit a PR with any corrections you find for the instructions below.

The development container included in this repository is derived from Microsoft's default Ubuntu development container. Contents of the Ubuntu Docker image can be in the VS Code devcontainer Ubuntu base Dockerfile. The contents of the container used for development can be found in the Dockerfile located in the same directory as this README.

Usage

  1. Ensure you have all Devcontainer Prerequisites
  2. Open the directory containing your tauri-apps/tauri code.
  3. Install the Remote Development extension pack for VS Code. This will be included if you install recommended workspace extensions upon opening this repository.
  4. Ensure Docker is running
  5. Open your workspace in the provided devcontainer: Open this repository in VS Code and run Remote-Containers: Reopen in Container... from the Command Palette (F1).

Devcontainer Prerequisites

Prerequisites are mainly derived from VS Code's instructions for usage of development containers, documented here: Developing inside a Container: Getting Started.

  1. Docker (Docker Desktop recommended)
  2. VS Code
  3. X window host - required if you want to be able to interact with a GUI from your Docker host

A note on filesystem performance

Due to limitations in how Docker shares files between the Docker host and a container, it's also recommended that developers clone Tauri source code into a container volume. This is optional, but highly advised as many filesystem/IO heavy operations (cargo build, pnpm install, etc) will be very slow if they operate on directories shared with a Docker container from the Docker host.

To do this, open your project with VS Code and run Remote-Containers: Clone Repository in Container Volume... from the Command Palette (F1).

Accessing a Tauri application running you the devcontainer

Docker Desktop provides facilities for allowing the development container to connect to a service on the Docker host. So long as you have an X window server running on your Docker host, the devcontainer can connect to it and expose your Tauri GUI via an X window.

Export the DISPLAY variable within the devcontainer terminal you launch your Tauri application from to expose your GUI outside of the devcontainer.

bash
export DISPLAY="host.docker.internal:0"

File: .changes/README.md

Changes

via https://github.com/jbolda/covector

As you create PRs and make changes that require a version bump, please add a new markdown file in this folder. You do not note the version number, but rather the type of bump that you expect: major, minor, or patch. The filename is not important, as long as it is a .md, but we recommend that it represents the overall change for organizational purposes.

When you select the version bump required, you do not need to consider dependencies. Only note the package with the actual change, and any packages that depend on that package will be bumped automatically in the process.

Use the following format:

md
---
'package-a': 'patch:enhance'
'package-b': 'patch:enhance'
---

Change summary goes here

Summaries do not have a specific character limit, but are text only. These summaries are used within the (future implementation of) changelogs. They will give context to the change and also point back to the original PR if more details and context are needed.

Changes will be designated as a major, minor or patch as further described in semver.

Given a version number MAJOR.MINOR.PATCH, increment the:

  • MAJOR version when you make incompatible API changes,
  • MINOR version when you add functionality in a backwards compatible manner, and
  • PATCH version when you make backwards compatible bug fixes.

Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format, but will be discussed prior to usage (as extra steps will be necessary in consideration of merging and publishing).

Additionally you could specify a tag for the change file to group it with other changes by prefixing the bump with :<tag>, for example:

md
---
'package-a': 'patch:enhance'
---

Change summary goes here

which will group this change file with other changes that specify the bug tag.

For list of available tags, see the changeTags key in ./config.json

File: bench/README.md

Tauri Bench








About Tauri

Tauri is a polyglot and generic system that is very composable and allows engineers to make a wide variety of applications. It is used for building applications for Desktop Computers using a combination of Rust tools and HTML rendered in a Webview. Apps built with Tauri can ship with any number of pieces of an optional JS API / Rust API so that webviews can control the system via message passing. In fact, developers can extend the default API with their own functionality and bridge the Webview and Rust-based backend easily.

Tauri apps can have custom menus and have tray-type interfaces. They can be updated, and are managed by the user's operating system as expected. They are very small, because they use the system's webview. They do not ship a runtime, since the final binary is compiled from rust. This makes the reversing of Tauri apps not a trivial task.

This module

This rust module run on CI, provides internal metrics results of Tauri. To learn more see benchmark_results repository.

*Internal use only

Semver

tauri is following Semantic Versioning 2.0.

Licenses

Code: (c) 2015 - 2021 - The Tauri Programme within The Commons Conservancy.

MIT or MIT/Apache 2.0 where applicable.

Logo: CC-BY-NC-ND

File: crates/tauri-utils/README.md

tauri-utils








Component Version
tauri-utils

About Tauri

Tauri is a polyglot and generic system that is very composable and allows engineers to make a wide variety of applications. It is used for building applications for Desktop Computers using a combination of Rust tools and HTML rendered in a Webview. Apps built with Tauri can ship with any number of pieces of an optional JS API / Rust API so that webviews can control the system via message passing. In fact, developers can extend the default API with their own functionality and bridge the Webview and Rust-based backend easily.

Tauri apps can have custom menus and have tray-type interfaces. They can be updated, and are managed by the user's operating system as expected. They are very small, because they use the system's webview. They do not ship a runtime, since the final binary is compiled from rust. This makes the reversing of Tauri apps not a trivial task.

This module

This is common code that is reused in many places and offers useful utilities like parsing configuration files, detecting platform triples, injecting the CSP, and managing assets.

To learn more about the details of how all of these pieces fit together, please consult this ARCHITECTURE.md document.

Semver

tauri is following Semantic Versioning 2.0.

Licenses

Code: (c) 2021 - The Tauri Programme within The Commons Conservancy.

MIT or MIT/Apache 2.0 where applicable.

Logo: CC-BY-NC-ND

File: crates/tauri-schema-worker/README.md

schema.tauri.app worker

Source code for https://schema.tauri.app cloudflare worker.

File: crates/tauri-schema-generator/README.md

tauri-schema-generator

This crate is part of the tauri monorepo workspace and its sole purpose is to generate JSON schema for various tauri config files.

File: crates/tauri-runtime-wry/README.md

tauri-runtime-wry




Component Version
tauri-runtime-wry

About Tauri

Tauri is a polyglot and generic system that is very composable and allows engineers to make a wide variety of applications. It is used for building applications for Desktop Computers using a combination of Rust tools and HTML rendered in a Webview. Apps built with Tauri can ship with any number of pieces of an optional JS API / Rust API so that webviews can control the system via message passing. In fact, developers can extend the default API with their own functionality and bridge the Webview and Rust-based backend easily.

Tauri apps can have custom menus and have tray-type interfaces. They can be updated, and are managed by the user's operating system as expected. They are very small, because they use the system's webview. They do not ship a runtime, since the final binary is compiled from rust. This makes the reversing of Tauri apps not a trivial task.

This module

This crate opens up direct systems-level interactions specifically for WRY, such as printing, monitor detection, and other windowing related tasks. tauri-runtime implementation for WRY.
None of the exposed API of this crate is stable, and it may break semver
compatibility in the future. The major version only signifies the intended Tauri version.

To learn more about the details of how all of these pieces fit together, please consult this ARCHITECTURE.md document.

Semver

tauri is following Semantic Versioning 2.0.

Licenses

Code: (c) 2021 - The Tauri Programme within The Commons Conservancy.

MIT or MIT/Apache 2.0 where applicable.

Logo: CC-BY-NC-ND

File: crates/tauri-runtime/README.md

tauri-runtime




Component Version
tauri-runtime

About Tauri

Tauri is a polyglot and generic system that is very composable and allows engineers to make a wide variety of applications. It is used for building applications for Desktop Computers using a combination of Rust tools and HTML rendered in a Webview. Apps built with Tauri can ship with any number of pieces of an optional JS API / Rust API so that webviews can control the system via message passing. In fact, developers can extend the default API with their own functionality and bridge the Webview and Rust-based backend easily.

Tauri apps can have custom menus and have tray-type interfaces. They can be updated, and are managed by the user's operating system as expected. They are very small, because they use the system's webview. They do not ship a runtime, since the final binary is compiled from rust. This makes the reversing of Tauri apps not a trivial task.

This module

This is the glue layer between tauri itself and lower level webview libraries.
None of the exposed API of this crate is stable, and it may break semver
compatibility in the future. The major version only signifies the intended Tauri version.

To learn more about the details of how all of these pieces fit together, please consult this ARCHITECTURE.md document.

Semver

tauri is following Semantic Versioning 2.0.

Licenses

Code: (c) 2021 - The Tauri Programme within The Commons Conservancy.

MIT or MIT/Apache 2.0 where applicable.

Logo: CC-BY-NC-ND

File: crates/tauri-macros/README.md

tauri-macros








Component Version
tauri-macros

About Tauri

Tauri is a polyglot and generic system that is very composable and allows engineers to make a wide variety of applications. It is used for building applications for Desktop Computers using a combination of Rust tools and HTML rendered in a Webview. Apps built with Tauri can ship with any number of pieces of an optional JS API / Rust API so that webviews can control the system via message passing. In fact, developers can extend the default API with their own functionality and bridge the Webview and Rust-based backend easily.

Tauri apps can have custom menus and have tray-type interfaces. They can be updated, and are managed by the user's operating system as expected. They are very small, because they use the system's webview. They do not ship a runtime, since the final binary is compiled from rust. This makes the reversing of Tauri apps not a trivial task.

This module

Create macros for the context, handler, and commands by leveraging the tauri-codegen crate.

To learn more about the details of how all of these pieces fit together, please consult this ARCHITECTURE.md document.

Semver

tauri is following Semantic Versioning 2.0.

Licenses

Code: (c) 2021 - The Tauri Programme within The Commons Conservancy.

MIT or MIT/Apache 2.0 where applicable.

Logo: CC-BY-NC-ND

2. Official Technical Reference & Guides (tauri-apps/tauri-docs)

File: README.md

Welcome to the home for Tauri 2.0 documentation - we're excited to have you! ✨

This repo is used to build the docs for Tauri at https://tauri.app.

If you are looking for the old v1 docs, see here.


Get Involved

Partners

For the complete list of sponsors please visit our website and Open Collective.

License

MIT License

Copyright (c) 2020-2023 Tauri Programme within The Commons Conservancy

File: src/content/docs/_fragments/cta.mdx

title: 'Create Tauri app'

import { Tabs, TabItem } from '@astrojs/starlight/components';

```sh frame=none sh <(curl https://create.tauri.app/sh) ``` ```sh frame=none irm https://create.tauri.app/ps | iex ``` ```sh frame=none sh (curl -sSL https://create.tauri.app/sh | psub) ``` ```sh frame=none npm create tauri-app@latest ``` ```sh frame=none yarn create tauri-app ``` ```sh frame=none pnpm create tauri-app ``` ```sh frame=none deno run -A npm:create-tauri-app ``` ```sh frame=none bun create tauri-app ``` ```sh frame=none cargo install create-tauri-app --locked cargo create-tauri-app ```

File: src/content/docs/about/book.md

title: The Tauri Book i18nReady: true

:::note[Progress Update]

We're actively working on authoring and writing The Tauri Book. We've encountered delays due to the immense growth of Tauri but have recently re-prioritized this project. While we don't yet have details on the timelines of a release, you can keep an eye on this page for updates.

We'd like to apologize for this being delayed beyond the originally communicated publish date. If you've donated through GitHub Sponsors or Open Collective and would like to request a refund you may do so via Open Collective: Contact Tauri on Open Collective.

:::

Overview

The Tauri Book will guide you through the history of Tauri and the design decisions we've made. It will also talk in depth about why privacy, security and sustainability are important and fundamental discussions you can apply to any modern software project.

Topics included are:

  • The method and reasoning behind the design of Tauri
  • The options you have when building with Tauri
  • That you don't have to choose between shipping fast and being sustainable and responsible
  • Why we chose the Rust language as a binding and application layer for Tauri
  • Why a binary review is important

History

In 2020, the manufacture of native-apps has become easier and more accessible than ever before. All the same, beginners and seasoned developers alike are confronted with tough choices in a rapidly changing landscape of security and privacy. This is especially true in the semi-trusted environment of user devices.

Tauri takes the guesswork out of the equation, as it was designed from the ground up to embrace new paradigms of secure development and creative flexibility that leverage the language features of Rust and lets you build an app using any frontend framework you like. Find out how you can design, build, audit and deploy tiny, fast, robust, and secure native applications for the major desktop and mobile platforms, all from the exact same codebase and in record time - without even needing to know the Rust programming language.

Authors and Tauri co-founders Daniel and Lucas take you on a journey from theory to execution, during which you will learn why Tauri was built and how it works under the hood. Together with guest insights that specialize in Open Source, DevOps, Security and Enterprise Architecture, this book also presents discourse-formatted philosophical discussions and open-source sustainability viewpoints from which your next-gen apps will profit - and your users will benefit.

File: src/content/docs/about/governance.md

title: Tauri Governance i18nReady: true

One of the main goals of the organizational structure of Tauri is to guarantee we stay true to our open source values and do so sustainably while respecting the health and well-being of contributors. The Tauri Programme within the Commons Conservancy was established to commit to those values, and facilitate an open, transparent and efficient governance process throughout the future development of the Tauri and its auxiliary materials.

Tauri Working Group

The Tauri Working Group is the collective framework created to enable this governance process. It's composed of the following components:

  • Working Group Members
  • Tauri Board & Board Directors
  • Domains & Domain Leads
  • Teams

Working Group Members

All of the individuals that make up the Tauri Working Group.

Tauri Board & Board Directors

The Tauri Board is the central decision making body for the Tauri Programme and is responsible for the overall health and stability of the Tauri Programme. The Board votes on major decisions within the Programme and issues raised by the Working Group.

An individual Board Director may be a technical contributor, be a stakeholder in Tauri's future, share experience from the industry, or have a passion for regulatory and legal aspects within Open Source.

Domains & Domain Leads

Domains are organizational units that represent an area of interest within Tauri.

Domain Leads are trusted contributors within the Tauri community with expertise in the Domain they are leading. They are responsible for setting direction, overseeing and supporting the activities within that Domain.

The current Domains and Domain leads are outlined in the Governance and Guidance repo on GitHub.

Teams

Teams are small groups of contributors that support or maintain specific areas of the Tauri Programme. They are a means for Tauri to execute its longer-term tasks and goals, especially when ad-hoc contributions cannot achieve the same results.

Get Involved

If you're interested in becoming a Tauri Board Director or a Domain Lead, elections for those positions are run throughout the year. For Domain Leads those take place in both the spring and fall and for Board Directors in the summer. Instructions for how to apply are posted to the Tauri Blog leading up to the respective election.

Additional Resources

File: src/content/docs/about/index.mdx

title: About Tauri i18nReady: true

:::tip

If you're looking for a quick technical overview and to start building an app then visit the What is Tauri page. If you'd like to learn more about the project's philosophy then keep reading.

:::

import { LinkCard, CardGrid } from '@astrojs/starlight/components';

File: src/content/docs/about/philosophy.md

title: Tauri Philosophy i18nReady: true

Tauri is a toolkit that helps developers make applications for the major desktop platforms - using virtually any frontend framework in existence. The core is built with Rust, and the CLI leverages Node.js making Tauri a genuinely polyglot approach to creating and maintaining great apps.

Security First

In today's world, every honest threat model assumes that the user's device has already been compromised. This puts app developers in a complicated situation because if the device is already at risk, how can the software be trusted?

Defense in depth is the approach we've taken. We want you to be able to take every precaution possible to minimize the surface area you present to attackers. Tauri lets you choose which API endpoints to ship, whether or not you want a localhost server built into your app, and it even randomizes functional handles at runtime. These and other techniques form a secure baseline that empowers you and your users.

Slowing down attackers by making static attacks crushingly difficult and isolating systems from one another is the name of the game. And if you are coming from the Electron ecosystem - rest assured - by default Tauri only ships binaries, not ASAR files.

By choosing to build Tauri with security as a guiding force, we give you every opportunity to take a proactive security posture.

Polyglots, not Silos

Most contemporary frameworks use a single language paradigm and are therefore trapped in a bubble of knowledge and idiom. This can work well for certain niche applications, but it also fosters a kind of tribalism.

This can be seen in the way that the React, Angular, and Vue development communities huddle on their stacks, ultimately breeding very little cross-pollination.

This same situation can be seen in the Rust vs. Node vs. C++ battlefields, where hardliners take their stances and refuse to collaborate across communities.

Today, Tauri uses Rust for the backend - but in the not too distant future, other backends like Go, Nim, Python, Csharp, etc. will be possible. This is because we are maintaining the official Rust bindings to the webview organization and plan to let you switch out the backend for your needs. Since our API can be implemented in any language with C interop, full compliance is only a PR away.

Honest Open Source

None of this would make any sense without a community. Today software communities are amazing places where people help each other and make awesome things - open source is a very big part of that.

Open source means different things to different people, but most will agree that it serves to support freedom. When software doesn't respect your rights, then it can seem unfair and potentially compromise your freedoms by operating in unethical ways.

This is why we are proud that FLOSS advocates can build applications with Tauri that are "certifiably" open source and can be included in FSF endorsed GNU/Linux distributions.

The Future

Tauri's future depends on your involvement and contributions. Try it out, file issues, join a working group or make a donation - every contribution is important. Please, at any rate, do get in touch!!!

File: src/content/docs/about/trademark.md

title: Trademark Guidelines i18nReady: true

This trademark policy was prepared to help you understand how to use the TAURI trademarks, service marks and logos owned by the Tauri Programme within the Commons Conservancy.

While our software is available under a free and open source software license, that copyright license does not include a license to use our trademark, and this Policy is intended to explain how to use our marks consistent with background law and community expectation.

This Policy covers:

  • Our word trademarks and service marks: TAURI, TAO, WRY
  • Our logos: The TAURI, TAO, WRY logos (and all visual derivatives)

This policy encompasses all trademarks and service marks, whether they are registered or not.

General Guidelines

Whenever you use one of our marks, you must always do so in a way that does not mislead anyone about what they are getting and from whom. For example, you cannot say you are distributing TAURI software when you’re distributing a modified version of it (aka a Fork), because recipients may not understand the differences between your modified versions and our own.

You also cannot use our logo on your website in a way that suggests that your website is an official website or that we endorse your website.

You can, though, say you like TAURI software, that you participate in the TAURI community, that you are providing an unmodified version of the TAURI software.

You may not use or register our marks, or variations of them as part of your own trademark, service mark, domain name, company name, trade name, product name or service name.

Trademark law does not allow your use of names or trademarks that are too similar to ours. You therefore may not use an obvious variation of any of our marks or any phonetic equivalent, foreign language equivalent, takeoff, or abbreviation for a similar or compatible product or service. We would consider the following too similar to one of our Marks:

  • TAURIMAGE
  • Tauri Wallet App

Acceptable Uses

Applications

TAURI is a framework for making applications for computing devices. You may claim that your application uses TAURI, but care should be taken to avoid giving the impression that your application is approved by The Tauri Programme within the Commons Conservancy, or is an official application. Care must be taken, not to ship your application with the default ICON.

Plugins & Templates

You may publish the code for plugins and templates using the appropriate naming conventions, but please mention that these works are not officially approved. Only such codebases that are managed by the organization within the GitHub organization tauri-apps are considered official.

Core Modifications (Forks)

If you distribute a modified version of our software (TAURI CORE), you must remove all of our logos and naming from it. You must retain our original license in SPDX format. You may use our word marks, but not our logos, to truthfully describe the origin of the software that you are providing. For example, if the code you are distributing is a modification of our software, you may say, “This software is derived from the source code for TAURI software.”

Statements About Compatibility

You may use the word marks, but not the logos, to truthfully describe the relationship between your software and ours. Any other use may imply that we have certified or approved your software. If you wish to use our logos, please contact us to discuss license terms.

Naming Compatible Products

If you wish to describe your product with reference to the TAURI software, here are the conditions under which you may do so. You may call your software XYZ (where XYZ is your product name) for TAURI only if:

  • All versions of the TAURI software you deliver with your product are the exact binaries provided by us, or manufactured by the core software and tooling we provide.
  • Your product is fully compatible with the APIs for the TAURI software.
  • You use the following legend in marketing materials or product descriptions: “TAURI is a trademark of The Tauri Programme within the Commons Conservancy. https://tauri.app/ ”

User Groups

You can use the Word Marks as part of your user group name provided that:

  • The main focus of the group is our software
  • The group does not make a profit
  • Any charge to attend meetings are to cover the cost of the venue, food and drink only

You are not authorized to conduct a conference using our marks.

No Domain Names

You must not register any domain that includes our word marks or any variant or combination of them.

Other For Profit Usage of the TAURI Marks

If you are making a video, tutorial series, book, or other educational material, for which you are receiving payment through subscriptions, sales, advertising or the like, then you must acquire explicit licensing permission from The Tauri Programme within the Commons Conservancy.

How to Display Our Marks

When you have the right to use our mark, here is how to display it.

Trademark Marking and Legends

The first or most prominent mention of a mark on a webpage, document, or documentation should be accompanied by a symbol indicating whether the mark is a registered trademark (“®”) or an unregistered trademark (“™”). If you don’t know which applies, contact us. (TAURI itself is a registered trademark.)

Place the following notice at the foot of the page where you have used the mark: TAURI is trademark of [The Tauri Programme within the Commons Conservancy].”

Use of Trademarks in Text

Always use trademarks in their exact form with the correct spelling, neither abbreviated, hyphenated, or combined with any other word or words.

  • Unacceptable: TAUREE
  • Acceptable: TAURI

Don’t pluralize a trademark.

  • Unacceptable: I have seventeen TAURIs running on my computer.
  • Acceptable: I am running seventeen TAURI applications on my computer and have ram to spare.

Always use a trademark as an adjective modifying a noun.

  • Unacceptable: This is a TAURI.
  • Acceptable: This is a TAURI software application.

Use of Logos

You may not change any logo except to scale it. This means you may not add decorative elements, change the colors, change the proportions, distort it, add elements, or combine it with other logos.

We have a high-contrast version of the logo, which you can download below in the assets section.

Assets

  • Here you may download the entire Brand Guidelines - (PDF, 74.3 MB)
  • Here you may download SVG and PNG formats of the LOGO and Wordmark in the Logopack - (ZIP, 203 KB)

The Tauri Programme within the Commons Conservancy retains all rights to the modification of these trademark guidelines at any time. If you have a question or enquiry, please send an email to [email protected].

These guidelines are based on the Model Trademark Guidelines, available at http://www.modeltrademarkguidelines.org, used under a Creative Commons Attribution 3.0 Unported license: https://creativecommons.org/licenses/by/3.0/deed.en_EU. Version 1.0 dated 20th, August 2022

File: src/content/docs/blog/create-tauri-app-version-3-released.md

title: create-tauri-app Version 3 Released date: 2023-03-01 authors: [amrbashir] excerpt: create-tauri-app Version 3 is released with support for alpha versions of Tauri, mobile project support and DX improvements image: ./create-tauri-app-version-3-released/header.jpg

A new major version of create-tauri-app has been released. This version adds support for the alpha version of Tauri 2.0, the ability to initialize iOS and Android projects and removes some less commonly used templates to make the project more maintainable.

Tauri 2.0 Alpha & Mobile Support

The first alpha version of Tauri 2.0 was published almost 3 months ago which brought initial mobile support for Android and iOS. Previously there wasn't an easy way to create a new project to test either the changes in the alpha version nor the mobile support. Well, that ends now!

Starting with version 3 of create-tauri-app, you can now pass --beta flag and it will bootstrap an app that uses [email protected]. When adding the --beta flag it will automatically prompt you if you'd like to add mobile support. You can also use the --mobile flag to automatically make it mobile compatible.

To get started:

bash
# pnpm
pnpm create tauri-app --alpha

# yarn
yarn create tauri-app --alpha

# npm
npm create tauri-app -- --alpha

# Cargo
cargo install create-tauri-app --locked
cargo create-tauri-app --alpha

# Bash
sh <(curl https://create.tauri.app/sh) --alpha

# Powershell
$env:CTA_ARGS="--alpha";iwr -useb https://create.tauri.app/ps | iex

Prompt Improvements

With version 2 of create-tauri-app we also focused on improving the flow and experience of the prompted questions.

Previously the second prompt would ask "Choose your package manager". This was a bit vague and could leave some with unanswered questions:

  • What is cargo?
  • Is it a new Node.js package manager?
  • Why choose it over pnpm or yarn?

This would be even more vague if we decided to add a new frontend language (such as a webassembly Golang web application). We added a prompt asking to choose the package manager to ask which language would you prefer. It looks something like this:

text
? Choose which language to use for your frontend ›
  Rust
❯ TypeScript / JavaScript  (pnpm, yarn, npm)

After choosing the frontend language create-tauri-app will then prompt for package manager to use if the language has multiple (such as Node.js with npm, yarn, and pnpm).

Another prompt that we felt problematic was the template selection prompt. It contained a lot of templates to choose from and was only growing with time:

text
✔ Choose your package manager · pnpm
? Choose your UI template ›
  vanilla
  vanilla-ts
  vue
❯ vue-ts
  svelte
  svelte-ts
  react
  react-ts
  solid
  solid-ts
  next
  next-ts
  preact
  preact-ts
  angular
  clojurescript
  svelte-kit
  svelte-kit-ts

We decided to split this up into 2 prompts. The first will ask which UI template to use:

text
✔ Choose your package manager · pnpm
? Choose your UI template ›
  Vanilla
❯ Vue
  Svelte
  React
  Solid
  Angular
  Next
  SvelteKit
  ClojureScript
  Preact

And then the second will then ask any additional choices that are specific to that template (such as choosing between TypeScript or JavaScript for Vue):

text
✔ Choose your package manager · pnpm
✔ Choose your UI template · Vue - (https://vuejs.org)
? Choose your UI flavor ›
❯ TypeScript
  JavaScript

Even with these refinements the list of templates was still quite large and would only grow over time. The next thing to look at was the list of templates themselves.

Removing Templates

When create-tauri-app version 2 was launched it quickly received PRs to add additional templates beyond what it originally launched with. While it was exciting to receive so much support from the community, it did bring up a couple of new challenges:

  • It made it almost impossible to fit them in a single prompt
  • Maintaining all the templates was becoming more difficult

It was a hard balance between showing how flexible Tauri is but also making sure that the project was maintainable and had the DX that we wanted.

We decided to focus on the most popular frontend frameworks and used guidance from community surveys like The State of JS and our own Tauri community feedback. With this we removed the next, next-ts, preact, preact-ts, clojurescript, svelte-kit and svelte-kit-ts templates and also closed PRs which aimed to add more templates.

Community-Maintained Templates & Previous Versions

We want to make sure that we offer a place for the Tauri community to provide their own templates for the frameworks they love. The templates section of awesome-tauri is just the place for that. We invite the community to submit a PR to the awesome-tauri repo with their templates so that they can be shared with the Tauri community. We'll also be creating a section on the Tauri website to highlight and showcase these community templates.

If you'd still like to use the previous templates from version 2 of create-tauri-app they are still published to npm and crates.io. Here's how you can use a previous version:

bash
# pnpm
pnpm create tauri-app@2

# yarn
yarn create tauri-app@2

# npm
npm create tauri-app@2

# Cargo
cargo install create-tauri-app --version 2.8.0 --locked
cargo create-tauri-app

# Bash
sh <(curl https://create.tauri.app/v/2.8.0/sh)

# Powershell
iwr -useb https://create.tauri.app/v/2.8.0/ps | iex

However, as time goes, these templates will become out of date as Tauri and the frontend frameworks move forward. We'd recommend you look at the community templates in the awesome-tauri repo and welcome submissions if something is missing.

We hope that these changes make it easier for the community to try out the alpha and beta versions of Tauri 2.0 and also make the process to create a new Tauri app easier for everyone! We'd love to hear your feedback and invite you to join the conversation on the GitHub Discussion for this post.

File: src/content/docs/blog/cve-2024-24576.md

title: Rust Security Advisory CVE-2024-24576 date: 2024-04-10 authors: [tweidinger, chip] excerpt: Recent Rust Security Advisory CVE-2024-24576.

The Rust Security Response WG announced CVE-2024-24576, which affects the Rust Standard Library on Windows.

TL;DR: Upgrade your Rust version to 1.77.2.

How Does it Affect Tauri as a Library?

Some Tauri organization repositories use batch files (cmd.exe under the hood) for developer environment tooling such as build scripts.
No reviewed repositories use batch files for runtime code.

We don't see additional risks for the Tauri project based on this CVE.

Nevertheless, we will update our CI systems to use the latest Rust version.

Is My Tauri App Affected?

In general you are possibly affected if you fulfil all of the below criteria:

  • You ship your app on Windows
  • Your project enables the Tauri v1 shell feature with "execute": true or the v2 shell-plugin with allow-execute permission
  • You allow arguments in the scope element of the shell feature
  • You pass untrusted input to cmd.exe or .bat/.cmd files and improperly validate the scope (🚩)

If any of these criteria are not fulfilled in your application you are likely NOT affected.

If you implement custom commands or logic written in your application that directly exposes the Rust Command with arguments provided at runtime, you may be affected.
While not Tauri specific, this pattern could affect any Rust project.

Conclusion

Please upgrade your Rust version to 1.77.2
as soon as possible and distribute updates to your users.

This investigation and writeup was performed in cooperation with our partner CrabNebula ❤️.

Read more about this security advisory here.
This affects many programming languages, this specific CVE is just the one filed for Rust.

Explore Related Technologies & Topics

View All 9,111+ Repositories →

Discover similar high-velocity repositories, agent skills, and OpenAPI specifications across the ecosystem.

#desktop-app Browse desktop-app catalog → #high-performance Browse high-performance catalog → #mobile-app Browse mobile-app catalog → #native-app Browse native-app catalog → #rust Browse rust catalog → #web-frontend Browse web-frontend catalog → ⚡ MCP Servers Model Context Protocol → 🧠 Agent Skills Prompt & rule files → 🔌 OpenAPI Specs REST & Swagger schemas →