Skip to content
ESEN
Contact

Technology · Desktop apps with Rust

Desktop app development with Tauri

Tauri lets you build a desktop application with the interface made in web technology and the core written in Rust. Instead of carrying a whole browser inside, it uses the one the system already ships, so the installer is small and the application uses less memory. We build new applications with Tauri and migrate the ones now in Electron.

Tell us about your project See an example

Often combined with

Fig. 01Two-layer benchCORE · RUSTappREAD FILESPRINTUSB PORTWIPE DISKWINDOW · PERMISSIONS · CORELooping
The window asks and the Rust core executes, but only the commands the permission board lets through: the one that is not listed finds its socket capped. The installers for each system come off the same bench.

Situations

What you can solve with a Tauri app

Tauri pays off when you want a real desktop application, with access to files and devices, without giving up a web interface your team already knows how to build.

  • A website that needs to leave the browser

    Working with local files, printing without dialogs, talking to a device or carrying on offline. The interface you already have is reused and gains a core that does reach the system.

  • An installer that weighs too much

    Applications that take up a lot of space and are slow to start because they carry a browser inside. With Tauri the system’s own is used and the package slims down.

  • The same app on Windows, macOS and Linux

    One codebase for the three systems, with their installers, their icons and their signatures. And, if needed, for mobile too.

  • An interface that must not be able to do everything

    The interface can only ask the system for what was allowed beforehand, command by command and folder by folder. If someone slips code into it, they do not inherit the keys to the machine.

The bridge: only named commands cross from the window to the core

What to check before starting

  • Which systems and versions it will be installed on
  • What it needs from the machine: files, printers, devices, network
  • Whether a web interface or an Electron app already exists to start from
  • How the installers are going to be signed and updated

Services

What we build with Tauri

Four kinds of job. The Rust core is what sets a Tauri app apart from a packaged website.

  • Module 1 · Window

    New desktop apps

    The whole application: interface in the web technology you prefer, menus, system tray, shortcuts and several windows, with the behavior of each operating system.

    Examples of deliverables

    • Internal management tool
    • Workstation with printing
    • Editor for your own documents
  • Module 2 · Core

    Rust core and system access

    What the app really does: reading and writing files, local database, heavy calculations and communication with devices, offered to the interface as named commands.

    Examples of deliverables

    • Local database with SQLite
    • Reading a device over USB
    • Processing of large files
  • Module 3 · Permission board

    Permissions and security

    What each window may ask for and on which folders, defined in a file that gets reviewed. Plus the content policy and the isolation of anything that comes from outside.

    Examples of deliverables

    • Access limited to one folder
    • Commands allowed per window
    • Review of an existing app
  • Module 4 · Installer press

    Migration from Electron and packaging

    Moving an Electron app to Tauri while keeping the interface, and signed installers for each system with their automatic update.

    Examples of deliverables

    • Screen-by-screen migration
    • Signed installer for Windows and macOS
    • Automatic update

A working example

What the window may ask for, and what it may not

Simulated demonstration. The window of an app tries four things. Next to it is the permission board: switch each one on or off and try again.

Simulated demo · sample data

Job reports

What the window tries

No data loaded.

Permission board

Delete outside the appThere is no switch: the core does not offer that command.

Between the window and the core

    No app is installed: the window and the core are simulated in your browser and no file is touched. The model is Tauri’s: what is not allowed beforehand, the interface cannot ask for.

    Integration

    How it fits with your systems

    A Tauri app has two halves: the one you see, made with web technology, and the one that works, in Rust. Only what is declared passes between the two.

    Where it comes from

    TauriDesktop app in Tauriweb interface, Rust core

    Where it goes

    Dependencies worth checking

    • Which web engine each system ships and which minimum versions are supported
    • Which libraries in the current interface depend on one specific browser
    • Which signing certificates are needed on Windows and on macOS
    • Which parts of an Electron app use Node modules that will have to be replaced

    How we work and what we deliver

    How we work on a Tauri job

    1. 01

      Initial review

      We look at the interface or the app that exists, what it needs from the machine and which systems it will be installed on.

    2. 02

      Scope

      We write down the windows, the commands the core offers, the permissions of each one and what is left out.

    3. 03

      First release

      An installer that opens on your machines, with the main path and one real access to the system.

    4. 04

      Validation

      You test it on all three systems if you use them, offline and on the most modest machine.

    5. 05

      Documentation

      How a version is compiled, signed and published, and the permissions file explained.

    What you get when the job closes

    • The code of the interface and of the core in your repository
    • Signed installers for each system
    • The permissions file, commented
    • The list of what is left out, and why

    Questions

    Questions about Tauri

    Missing yours? Write it to info@veodar.com and we'll reply with a specific question, not a brochure.

    How is Tauri different from Electron?

    Electron carries its own browser and Node.js inside; Tauri uses the system’s browser and puts the logic in Rust. The result is a much lighter installer and less memory in use, in exchange for checking the interface on each system’s web engine. Electron is still reasonable for apps that already exist or that depend on its ecosystem.

    Do I need to know Rust to maintain the app?

    To change the interface, no: it is web technology. To change what the app does with the system, Rust is needed, although it tends to be little code and stable. We document where the boundary is so your team knows what it can touch.

    Does the interface look the same on all three systems?

    Nearly, but it should not be taken for granted. Each system draws with its own web engine and there are small differences in fonts, scrolling or recent features. That is why it is tested on all three from the start and not at the end.

    Can you migrate my Electron app?

    In many cases, yes. The interface is kept almost whole; what changes is the part that uses Node.js, which is rewritten in Rust or replaced with Tauri plugins. First we review which native modules it uses, which is what decides the effort.

    Is Tauri suitable for an app that works offline?

    Yes. The app and its data live on the machine, usually in a SQLite database, and it synchronizes when there is a network. It is one of the usual reasons for leaving the browser.

    And for mobile as well?

    Since version 2, Tauri can produce apps for iOS and Android with the same core. It is an option when the desktop comes first and mobile is a complement; for an app designed for the phone first we usually propose other technologies.

    Updated:

    Related services

    All services

    Other technologies

    What it is combined with

    All technologies
    • Rust developmentApplications, services and modules that cannot fail or run slow. We write the core of your product in Rust, or the piece that is holding it back today.
    • Offline data with SQLiteThe app stores and queries on the phone itself and syncs when coverage returns. We design the local model, the change queue and the encryption.
    • Signing and automatic updatesSigned installers the system accepts without warnings and new versions that reach every workstation by themselves, with a rollback if something fails.

    Get started

    Tell us which application you want to bring to the desktop.

    Knowing what it does, on which systems and what it needs from the machine is enough for a first answer.

    What helps us assess it

    • What the app does and who uses it
    • Which operating systems it is installed on
    • What it needs from the machine: files, printers, devices
    • Whether a website or an Electron app already exists
    Tell us about your project info@veodar.com

    Before you write, see how we price a project or our solutions by department.

    Fig. 07Morse keyH · E · L · L · O