<!-- Stacklift documentation: "Desktop apps". Source: https://stacklift.joynul.com/docs/desktop · All pages for LLMs: https://stacklift.joynul.com/llms-full.txt -->

> About Stacklift: Stacklift is a hosted platform with source-available SDKs for shipping app releases and over-the-air updates. It works for mobile (React Native, Expo, Flutter, native iOS and Android, Kotlin Multiplatform, .NET MAUI, Unity), web, desktop (Electron, .NET, Java) and backend apps. Developers create releases with the `stacklift` CLI or the dashboard; the server verifies and signs every artifact (SHA-256 + Ed25519), deploys releases to channels with staged rollouts and rollback, and app SDKs check, download and verify updates. Native apps can change screens over the air with server-driven UI layouts and logic with sandboxed scripts, within App Store and Google Play rules. Apps never depend on Stacklift to keep working: everything has a built-in fallback and an exit path.
>
> This page: Signed installer updates for Electron, .NET, Java and other desktop apps.

# Desktop apps

Desktop apps (Electron, Tauri, Flutter desktop, .NET, Qt, JVM, native macOS, Kotlin/Compose Desktop, Unity players …) update differently from mobile apps, and Stacklift models that instead of pretending they're the same.

## How a desktop update works

1. You build a **signed installer** per OS and upload it as a `desktop-installer` artifact.
2. Stacklift verifies the bytes server-side, signs them with the project's Ed25519 key, and serves them to devices on a channel — optionally as a [staged rollout](https://stacklift.joynul.com/docs/concepts.md) with the usual pause and cancel controls.
3. The app's SDK **checks, downloads and verifies** the installer (signature → size → SHA-256).
4. **Your app runs the installer** and relaunches. Stacklift can't do that for you.

Unlike mobile `native-binary` records — which are tracked and *never* delivered — `desktop-installer` artifacts are delivered, because for desktop software the OS-level installer is the update mechanism.

```bash
stacklift release create --version 3.1.0 \
  --artifact windows:desktop-installer:dist/Acme-Setup-3.1.0.msi \
  --artifact macos:desktop-installer:dist/Acme-3.1.0.dmg \
  --artifact linux:desktop-installer:dist/Acme-3.1.0.AppImage \
  --channel staging
```

Installer extensions must match the platform: `.exe` / `.msi` / `.msix` are Windows, `.dmg` / `.pkg` are macOS, `.AppImage` / `.deb` / `.rpm` are Linux; `.zip` and `.tar.gz` fit any. Uploading a `.dmg` as a Windows build is rejected before anything is stored.

## What Stacklift does not do

- **No OS code signing or notarization.** Stacklift's Ed25519 signature is independent of Authenticode and Apple's Developer ID + notarization. Unsigned installers trigger SmartScreen / Gatekeeper warnings or are blocked. That's your build pipeline's job.
- **No rollback.** Most OS installers refuse downgrades, so `desktop-installer` is never rollbackable through Stacklift. Fix forward with a higher version. (Config and asset bundles can still be rolled back.)
- **No delta or silent in-place patching.** Every update is a full installer.
- **No store updates.** Builds from the Mac App Store or Microsoft Store must update through that store. Track them with `native-binary` records if you want visibility.
- **No hot-swapping app code.** Electron `app.asar` / Tauri frontend swaps are *planned*, not implemented — they interact with ASAR integrity fuses and macOS code-signature validity.

## Choosing an SDK

| Stack | Use | Status |
| --- | --- | --- |
| Electron | `@stacklift/sdk-electron` | Tested with fakes for Electron's APIs; not run inside a real Electron app |
| Flutter desktop | `stacklift` (Dart) | Tested on the Dart VM |
| .NET WPF / WinForms / WinUI / MAUI | `Stacklift.Sdk` | Tested on .NET 10 |
| JavaFX / Compose Desktop / Swing / KMP `jvmMain` | Java SDK | Tested on JDK 21 |
| macOS (Swift / AppKit) | Swift package | Tested with `swift test` on macOS |
| Tauri | `@stacklift/sdk-js` from the frontend, or `packages/sdk-tauri` | Rust crate **untested** |
| Qt / C++, GTK, Win32, Go, Rust | none — implement the [contract](https://stacklift.joynul.com/docs/sdk.md#the-contract) | — |

See [SDKs](https://stacklift.joynul.com/docs/sdk.md) for usage and the shared [conformance vectors](https://stacklift.joynul.com/docs/sdk.md#conformance).

## Verification flow in the app

```
check(channel, platform=windows, runtimeVersion=3.0.0)
   └─ manifest (kind=desktop-installer, sha256, size, signature, filename)
verify signature  ── fails → key_mismatch / signature_invalid, nothing is downloaded
download → <name>.part, hashing as it streams, aborting if it exceeds the signed size
size ✓  sha256 ✓  → rename to <name>.msi            ── any failure deletes the .part file
(your app) open installer, quit, relaunch
(new version, first launch) report INSTALL_SUCCESS    ── the real success signal
```

The installer's file name arrives from the server **unsigned**. SDKs that write it to disk reduce it to a base name and allow only installer extensions for the OS; do the same if you write your own client.

## Runtime version for desktop

`runtimeVersion` is the compatibility line of the installed app. For a desktop app that always ships a complete installer, simply keep it equal to the major version (or any value you only change on a breaking change). A device only receives releases whose `runtimeVersion` equals its own, so bump it when you want to stop offering a new installer to older lines.

## Cross-platform stacks

Flutter, Kotlin Multiplatform, .NET MAUI and Unity are listed under **Mobile** and again under **Desktop** in the project wizard because one project can target both: mobile builds are tracked as native releases, desktop builds are delivered as installers. Pick the platforms per release.
