Generate a Tauri + Rust desktop app from your PRD in 10 minutes

What You Will Build

A cross-platform desktop application built with Tauri and Rust, generated from a paragraph. The generated app includes:

• A Rust backend with #[tauri::command] handlers
• Typed Rust structs and enums for your domain
• An embedded SQLite store (local-first — this is a desktop app, not a multi-tenant web service)
• A React frontend rendered in the Tauri webview
• Cargo.toml and a tauri.conf.json ready for cargo tauri dev and cargo tauri build

Tauri + Rust is the right pick when you want a small, fast, native desktop app with a web UI and a Rust core — no Electron-sized binary.

A Note on Architecture: Desktop Is Different

The web stacks in Archiet generate multi-tenant servers with organisation-scoped queries. A Tauri app is local-first: it runs on one user's machine with a local database. So the framing is different — there is no org_id tenancy because there is one user. The Rust core owns the data; the webview is the UI.

Prerequisites

• An Archiet account (free at archiet.com/register)
• The Rust toolchain (rustup) and the Tauri prerequisites for your OS
• 10 minutes

---

Step 1: Write a Minimal PRD

NoteVault is a desktop app for personal notes. The user creates notes with a
title, body, and tags, organises them into notebooks, and searches across all
notes. Everything is stored locally. No login — single user on their own
machine.

Archiet maps these to Rust structs (Note, Notebook), an SQLite schema, and the Tauri commands to drive them.

Step 2: Open the Blueprint Wizard

Log in at archiet.com/login, click New Blueprint, paste the PRD, click Analyse, review the model.

Step 3: Choose Tauri + Rust

On the Generate screen, select Tauri + Rust and click Generate.

Step 4: What You Get

note-vault/
├── src-tauri/
│   ├── src/
│   │   ├── main.rs             # Tauri builder + command registration
│   │   ├── models.rs           # Rust structs/enums
│   │   ├── commands.rs         # #[tauri::command] handlers
│   │   └── db.rs               # SQLite access
│   ├── Cargo.toml
│   └── tauri.conf.json
├── src/                        # React webview frontend
│   ├── App.tsx
│   └── components/
└── package.json

The Rust struct and command are idiomatic Tauri:

// src-tauri/src/models.rs
#[derive(serde::Serialize, serde::Deserialize)]
pub struct Note {
    pub id: String,
    pub title: String,
    pub body: String,
    pub tags: Vec<String>,
    pub notebook_id: Option<String>,
}

// src-tauri/src/commands.rs
#[tauri::command]
pub fn list_notes(state: tauri::State<Db>) -> Result<Vec<Note>, String> {
    state.query_notes().map_err(|e| e.to_string())
}

The React frontend calls the command with Tauri's invoke:

import { invoke } from "@tauri-apps/api/core";
const notes = await invoke<Note[]>("list_notes");

The Rust core owns persistence; the webview just renders and invokes commands.

Step 5: Run It Locally

cd note-vault
npm install
cargo tauri dev

A native window opens running your app. The Rust backend and the React frontend hot-reload as you edit. To produce a distributable:

cargo tauri build

This builds a native installer for your platform (.dmg, .msi, or .AppImage).

What to Do Next

Ship native installers: cargo tauri build produces signed, distributable installers per OS.

Add native capabilities: Tauri exposes the filesystem, notifications, and OS APIs through its plugin system — extend the Rust core to use them.

Other stacks: if you actually need a multi-user web service rather than a desktop app, generate the same domain as a web stack like NestJS or FastAPI.

---

The generated ARCHITECTURE.md documents the local-first design, the command surface between the webview and the Rust core, and the SQLite schema.