Getting Started with Rust and Tauri

Today we will learn about Rust and Tauri and creating a basic application in Rust with Tauri. Before we get into the app creation, let us learn a little about Rust and Tauri.

Rust

Rust is a programming language that facilitates the creation of more dependable, quick applications. In programming language design, high-level ergonomics and low-level control frequently clash; Rust resolves this tension. Rust gives you the option to regulate low-level details (like memory use) without all the headache typically associated with such control by striking a balance between robust technical capability and an excellent development experience.

Installation

The first step is to install Rust. We’ll download Rust through rustup, a command line tool for managing Rust versions and associated tools. You’ll need an internet connection for the download.

The following steps install the latest stable version of the Rust compiler. Rust’s stability guarantees ensure that all the examples in the book that compile will continue to compile with newer Rust versions. The output might differ slightly between versions, because Rust often improves error messages and warnings. In other words, any newer, stable version of Rust you install using these steps should work as expected with the content of this book.

Command Line Notation

In this chapter and throughout the book, we’ll show some commands used in the terminal. Lines that you should enter in a terminal all start with $. You don’t need to type in the $ character; it’s the command line prompt shown to indicate the start of each command. Lines that don’t start with $ typically show the output of the previous command. Additionally, PowerShell-specific examples will use > rather than $.

Installing rustup on Linux or macOS

If you’re using Linux or macOS, open a terminal and enter the following command:

$ curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh

The command downloads a script and starts the installation of the rustup tool, which installs the latest stable version of Rust. You might be prompted for your password. If the install is successful, the following line will appear:

Rust is installed now. Great!

You will also need a linker, which is a program that Rust uses to join its compiled outputs into one file. It is likely you already have one. If you get linker errors, you should install a C compiler, which will typically include a linker. A C compiler is also useful because some common Rust packages depend on C code and will need a C compiler.

On macOS, you can get a C compiler by running:

$ xcode-select --install

Linux's users should generally install GCC or Clang, according to their distribution’s documentation. For example, if you use Ubuntu, you can install the build-essential package.

Installing rustup on Windows

On Windows, go to https://www.rust-lang.org/tools/install and follow the instructions for installing Rust. At some point in the installation, you’ll receive a message explaining that you’ll also need the MSVC build tools for Visual Studio 2013 or later. To acquire the build tools, you’ll need to install Visual Studio 2022. When asked which workloads to install, include:

• “Desktop Development with C++”
• The Windows 10 or 11 SDK
• The English language pack component, along with any other language pack of your choosing

Updating and Uninstalling

Once Rust is installed via rustup, when a new version of Rust is released, updating to the latest version is easy. From your shell, run the following update script:

$ rustup update

To uninstall Rust and rustup, run the following uninstall script from your shell:

$ rustup self uninstall

Creating a Project Directory

You’ll start by making a directory to store your Rust code. It doesn’t matter to Rust where your code lives, but for the exercises and projects in this book, we suggest making a projects directory in your home directory and keeping all your projects there.

Open a terminal and enter the following commands to make a projects directory and a directory for the “Hello, world!” project within the projects directory.

For Linux, macOS, and PowerShell on Windows, enter this:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

For Windows CMD, enter this:

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

Writing and Running a Rust Program

Next, make a new source file and call it main.rs. Rust files always end with the .rs extension. If you’re using more than one word in your filename, the convention is to use an underscore to separate them. For example, use hello_world.rs rather than helloworld.rs.

Now open the main.rs file you just created and enter the following code:

Filename: main.rs

fn main() {
    println!("Hello, world!");
}

Save the file and go back to your terminal window in the ~/projects/hello_world directory. On Linux or macOS, enter the following commands to compile and run the file:

$ rustc main.rs
$ ./main
Hello, world!

On Windows, enter the command .\main.exe instead of ./main:

> rustc main.rs
> .\main.exe
Hello, world!

Regardless of your operating system, the string Hello, world! Should print to the terminal.

If Hello, world! Did print, congratulations! You’ve officially written a Rust program. That makes you a Rust programmer—welcome!

Cargo

Cargo is the Rust package manager. Cargo downloads your Rust package's dependencies, compiles your packages, makes distributable packages, and uploads them to crates.io, the Rust community’s package registry.

Cargo is distributed by default with Rust, so if you've got rustc installed locally you probably also have cargo installed locally. 

To start a new package with Cargo, use cargo new:

$ cargo new hello_world

Let’s check out what Cargo has generated for us:

$ cd hello_world

$ tree .
.
├── Cargo.toml
└── src
    └── main.rs
1 directory, 2 files

This is all we need to get started. First, let’s check out Cargo.toml:

[package]

name = "hello_world"
version = "0.1.0"
edition = "2021"
[dependencies]

This is called a manifest, and it contains all the metadata that Cargo needs to compile your package.

Here’s what’s in src/main.rs:

fn main() {
    println!("Hello, world!");
}

Cargo generated a “hello world” program for us, otherwise known as a binary crate. Let’s compile it:

$ cargo build
   Compiling hello_world v0.1.0 (file:///path/to/package/hello_world)

And then run it:

$ ./target/debug/hello_world
Hello, world!

We can also use cargo run to compile and then run it, all in one step:

$ cargo run
     Fresh hello_world v0.1.0 (file:///path/to/package/hello_world)
   Running `target/hello_world`
Hello, world!

Tauri

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.

At the heart of every Tauri app is a Rust binary that manages windows, the webview, and calls to the operating system through a Rust crate called tauri. This project is managed by Cargo, the official package manager and general-purpose build tool for Rust.

Tauri CLI uses Cargo under the hood, so you rarely need to interact with it directly. Cargo has many more useful features that are not exposed through CLI, such as testing, linting, and formatting.

INSTALL TAURI CLI

$ cargo install tauri-cli

The easiest way to scaffold a new project is the create-tauri-app utility. It provides opinionated templates for vanilla HTML/CSS/JavaScript and many frontend frameworks like React, Svelte, and Yew.

$ cargo install create-tauri-app
$ cargo create-tauri-app

The above command will give you a installation stetup asking for:

1. Project Name
2. Package Manager
3. UI Template

After entering data to these options, you will have the app created.

The app contains a folder called src-tauri. It's a convention for Tauri apps to place all core-related files into this folder. Let's quickly run through the contents of this folder:

• Cargo.toml
  Cargo's manifest file. You can declare Rust crates your app depends on, metadata about your app, and much more.
• tauri.conf.json
  This file lets you configure and customize aspects of your Tauri application from the name of your app to the list of allowed APIs. See Tauri's API Configuration for the full list of supported options and in-depth explanations for each.
• src/main.rs
  This is the entry point to your Rust program and the place where we bootstrap into Tauri. You will find two sections in it:
  
  #![cfg_attr(
      all(not(debug_assertions), target_os = "windows"),
      windows_subsystem = "windows"
   )]
  fn main() {
  tauri::Builder::default()
     .run(tauri::generate_context!())
     .expect("error while running tauri application");
  }
  
  The line beginning with cfg! macro serves just one purpose: it disables the command prompt window that would normally pop up on Windows if you run a bundled app. If you're on Windows, try to comment it out and see what happens.
  The main function is the entry point and the first function that gets invoked when your program runs.
• icons
  Chances are you want a snazzy icon for your app! To get you going quickly, we included a set of default icons. You should switch these out before publishing your application. Learn more about the various icon formats in Tauri's icons feature guide.

And that's it! Now you can run the following command in your terminal to start a development build of your app:

$ cargo tauri dev

To build and bundle your Tauri application into a single executable, simply run the following command:

$ cargo tauri build

This will create a distributable bundle that can be shared for using the app.

Tauri opens up desktop apps using web technologies and your favourite frontend framework to better performance and smaller bundles.

I sincerely hope that the majority of you find the approach covered here to be helpful. Thank you for reading, and please feel free to leave any comments or questions in the comments section below.