Generate a production Tauri + Rust desktop application — IPC, state machines, SQLite, code signing, and CI/CD — from your architecture

What you get in the generated ZIP

tauri-app/
├── src-tauri/
│   ├── Cargo.toml                          # tauri, rusqlite, tokio, serde, serde_json
│   ├── tauri.conf.json                     # App id, bundle identifier, allowlist,
│   │                                        # updater endpoint + pubkey
│   ├── src/
│   │   ├── main.rs                         # Entry: Mutex state setup, plugin registration,
│   │   │                                    # all #[tauri::command] registration
│   │   ├── commands/
│   │   │   └── {ipc_command}.rs            # One file per IPC command: typed args + return,
│   │   │                                    # State<'_> injection, Result<T, String>
│   │   ├── services/
│   │   │   └── {runtime_service}.rs        # Arc<Mutex<T>> state machine: enum states,
│   │   │                                    # transition guard, health pulse, degraded mode
│   │   ├── db/
│   │   │   ├── connection.rs               # rusqlite connection pool, lazy_static,
│   │   │   │                               # migrations runner
│   │   │   └── migrations/
│   │   │       └── 001_initial.sql         # Schema for declared entities
│   │   └── retrieval/                       # Present when retrieval_indexes declared
│   │       └── {index}.rs                  # Corpus loader, FTS5 full-text index,
│   │                                        # confidence-weighted reranker
│   └── icons/                              # 512×512 + platform-specific icon assets
├── src/
│   ├── main.tsx                            # React + Vite entry
│   ├── App.tsx                             # Root: router + theme provider
│   ├── api/
│   │   └── ipc.ts                          # Typed TypeScript wrappers — invoke<T>()
│   │                                        # for every registered command
│   └── pages/
│       └── {Page}.tsx                      # One page per genome module
├── .github/workflows/
│   └── tauri-release.yml                   # matrix: windows-latest, macos-latest,
│                                            # ubuntu-latest
│                                            # steps: cargo check → test → tauri build
│                                            #        → sign → upload release asset
└── README.md                               # Build + release checklist

What's already wired

Type-safe IPC — Rust structs ↔ TypeScript interfaces are in sync: Every IPC command has a Rust #[tauri::command] function with typed Deserialize args and Serialize return, plus a matching TypeScript invoke<ReturnType>() wrapper in src/api/ipc.ts. Change the Rust signature and the TypeScript wrapper updates in the same render — they come from the same genome declaration.

Thread-safe state — Arc<Mutex<T>> throughout: Tauri commands run on async threads. State that isn't wrapped in Arc<Mutex<T>> causes compile errors (or worse, subtle race conditions if you work around the borrow checker). Every generated runtime service manages its state with Arc<Mutex<T>> and exposes it to the Tauri state system via .manage() in main.rs.

Rust state machine with transition guards: When your genome declares state transitions, the generated services/{name}.rs implements a transition(&str) -> Result<(), String> method with an exhaustive match. Calling a transition that doesn't exist from the current state returns Err — caught in the IPC command and returned as a String error to the TypeScript caller.

Embedded SQLite with migration runner: When local_store.kind: sqlite is declared, rusqlite is added to Cargo.toml and db/connection.rs implements a lazy-static connection with a migration runner that executes numbered SQL files from db/migrations/ in order on first boot. No ORM magic — plain SQL with rusqlite's typed row extraction.

Multi-platform code-signed CI: The GitHub Actions matrix builds on windows-latest, macos-latest, and ubuntu-latest in parallel. Code signing uses environment secrets (TAURI_KEY_PASSWORD, APPLE_ID, etc.) — not hardcoded. The release step uploads the signed .msi, .dmg, and .AppImage as release assets.

Auto-updater wired when declared: If your genome includes auto_update.endpoint, tauri.conf.json gets the updater block with your endpoint and public key env var reference. The update check runs on app launch.

Two-flow translation contract (when retrieval_indexes declared): Applications that declare retrieval_indexes (canonical text corpora — scripture, legal text, medical references) use corpus lookup, never machine-translation APIs, for those sources. The pipeline files include a header comment documenting which flow applies and why.

What ships in docs/

• docs/decisions/ADR-tauri-vs-electron.md — bundle size, memory usage, security surface, native API access; Electron and Flutter listed as rejected alternatives with documented reasons
• docs/compliance/desktop-code-signing.md — Windows EV cert, macOS notarization, Linux AppImage signing procedure
• docs/runbooks/tauri-release.md — local build, GitHub Actions matrix build, updating tauri.conf.json updater endpoint, publishing a release

Internal links

• Tauri + Rust integration for the full generated file reference and genome schema
• SAP BTP genome for cloud-side counterpart when the desktop app has a server component

CTA

Try it — free plan, no credit card. archiet.com.

Add desktop_runtime: { framework: tauri } to your genome. Generate. Run cargo check on the output. See whether it compiles before you've written a line.