Desktop Apps with RUST

Blogs

September 25, 2026

Tl;DR

From Go and Python to Rust desktop apps

Intro

WHY Im writting this post: bc the go-karting desktop was cool, the PWA Gopro version with ffmpeg even more and the dji tello Qt Desktop could be better
What Ive learnt with it: Ive ended

This year I have used Go to make one of my first desktop apps around the GoPro telemetry and ffmpeg

https://github.com/JAlcocerT/go-karting - Tinkered here

Also…flutter to some extent: for the tello here, and a comparison with flet

So im just curious, if there are so nice RUST apps like: Zed, open drone log

And also rust can make things be cross-platform…

Rust vs Go for Desktop

For Rust, the equivalent to Wails is Tauri.

In 2026, Tauri 2.0 is the industry standard for combining a Rust backend with a Vue frontend.

While Wails feels like “Go with a web UI,” Tauri feels like “a secure Rust core that happens to have a web UI.”

The workflow is almost identical to what you’ve seen with Go, but the folders and commands change slightly.

The Quick Start (The “Tauri” Way)

To scaffold a Rust + Vue project, you use the create-tauri-app utility.

It handles all the boilerplate for you.

# 1. Start the interactive wizard
npm create tauri-app@latest

During the prompts, choose:

Project Name: my-rust-hud
Frontend Language: TypeScript / JavaScript
Package Manager: npm (or pnpm / bun)
UI Template: Vue
UI Flavor: Vue - (Vite)

Project Structure Comparison

If you looked at both folders side-by-side, you’d see they are “cousins”:

Feature	Go + Wails	Rust + Tauri
Backend Folder	`/main.go` or `/app.go`	`/src-tauri/src/main.rs`
Frontend Folder	`/frontend`	`/src` (at the root)
Config File	`wails.json`	`src-tauri/tauri.conf.json`
Dev Command	`wails dev`	`npm run tauri dev`
Build Command	`wails build`	`npm run tauri build`

How the “Bridge” Looks in Rust

In Wails, you “bind” a Go struct. In Tauri, you define Commands and register them in your main loop.

The Rust Backend (main.rs):

// A simple function to get CPU data for your HUD
#[tauri::command]
fn get_stats() -> String {
    "CPU: 12% | RAM: 4GB".into()
}

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![get_stats]) // Register it
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

The Vue Frontend (App.vue):

import { invoke } from '@tauri-apps/api/core'

async function updateHUD() {
  // Call the Rust function directly
  const stats = await invoke('get_stats')
  console.log(stats)
}

Why choose Rust/Tauri over Go/Wails?

If you are already leaning toward Vue, here is why you might pick the Rust version:

Mobile Support: In 2026, Tauri 2.0 allows you to turn that same Vue HUD into an Android or iOS app with almost zero changes. Wails is currently focused almost entirely on Desktop.
Security: Tauri has a “Capabilities” system. You can strictly forbid your Vue frontend from touching the internet or specific folders unless you explicitly allow it in a config file.
Plugins: Tauri has a massive ecosystem of pre-built plugins (for Biometrics, NFC, Deep Linking, etc.) that are easier to drop in than Wails equivalents.
Go + Wails is your “Speed Demon”: You’ll have a working prototype by lunch.
Rust + Tauri is your “Tank”: It takes longer to build, but it’s more secure, slightly faster, and can run on your phone.

Since you’ve already installed Zed (which uses Rust), would you like to try running the Tauri init command to see if your Rust environment is ready?

Desktop Apps with RUST

Rust vs Go for Desktop

Conclusions

Why not just RemotionJS

FAQ

Where to find OSS?

Streamlit PWA with stlite