Roadmap and status
An honest ledger. Done means implemented and covered by tests or verified end to end; Partial and Planned are exactly that.
Phase 1 — Product foundation: done
Monorepo, Prisma schema + migration, authentication (email/password, email verification, password reset, Google and GitHub sign-in through Firebase), organizations, workspaces, members, invitations, RBAC, audit log, project management, adapter registry with capability matrix, dashboard and the full web app, OpenAPI.
Phase 2 — Release infrastructure: done
Presigned uploads, server-side verification and signing, release state machine, channels, environments, release history and comparison, promotion, rollback with compatibility safeguards.
Phase 3 — Developer experience: done (CLI) / partial (SDK)
stacklift CLI with JSON output and CI support (releases, channels, rollouts, store state, project keys, tokens, webhooks, layouts, audit log; the npm release is prepared, not published), stacklift.yaml, client SDKs (check, download, verify, report — see Phase 6), CI guides. The SDKs perform delivery and verification; applying updates on-device is stack-specific (see Phase 4).
Phase 4 — Update engines: started
| Adapter | State |
|---|---|
| React Native (JS bundles) | Code push works (packages/sdk-react-native): new bundle on the next launch, confirm, crash recovery and rollback, plus server-driven screens. Verified on the iOS simulator, an Android emulator and a physical HONOR ELI-NX9 phone (Android 16); not published to npm |
| Web / Next.js / Vue / Nuxt / Angular / Svelte / SvelteKit | Supported as artifact + channel deployment (Stacklift doesn't host the site) |
| Node / Python / Go / Java / .NET | Release + deployment tracking; container-image-ref for images. Stacklift doesn't run your servers |
| Flutter (Dart OTA) | Planned — needs a patched engine and patch builder |
| Android / iOS native | Binaries ship through the stores and are tracked. Over the air: server-driven screens (SwiftUI, Compose) and scripted logic (JavaScriptCore, QuickJS), verified on the iOS simulator and an Android 17 emulator |
| Expo / Capacitor / NativeScript | Partial: control plane and delivery work, sdk-js verifies; no on-device loader yet (an Expo app with its native folders could use the React Native package, but that is not tested) |
| Kotlin Multiplatform, .NET MAUI, Unity | Mobile builds tracked as native releases; desktop builds delivered as installers |
| Desktop: Electron, Tauri, Flutter desktop, .NET, macOS, Qt, JVM, other | Partial — signed installers are delivered and verified; your app runs them. No rollback, no delta updates, no OS code signing |
Phase 5 — Production infrastructure: partial
Done: staged rollouts with opt-in auto-expansion and failure-rate pause, analytics, live updates (SSE), webhooks with retries, rate limiting, audit. A single-server deployment (Docker, Caddy with automatic HTTPS, a GitHub Actions deploy with health-checked rollback) is written and its pieces are checked, described in the internal deploy guide; it has not been run against a real server yet. Planned or not yet done: CDN URL signing (S3 presigned URLs work today), per-runtime-version channel pointers, billing and plan enforcement, SSO/SCIM, 2FA, notification channels (Slack, Discord), source-control triggers (GitHub/GitLab/Bitbucket apps), first-party CI actions, columnar telemetry store, KMS-backed signing keys, storage lifecycle automation.
Phase 6 — Client SDKs and desktop: done (tested SDKs) / untested (Kotlin, Rust)
29 adapters across mobile, desktop, web and backend. A new desktop-installer artifact kind and desktop-update mechanism. SDKs for TypeScript (sdk-js, sdk-electron), Swift, Dart/Flutter, .NET and Java, each passing the same 14 signature conformance vectors; sdk-js is also tested against the real API end to end.
Verified in a real app: the Swift SDK (in a SwiftUI app) and the Dart/Flutter SDK (in a Flutter app) on the iOS simulator, and the Android SDK (in a Compose app) and the Flutter app on an Android 17 emulator, and the Android SDK and the React Native package on a physical HONOR ELI-NX9 (Android 16), all against a live server: update checks, downloads, scripts, server-driven layouts, code push and rollback. Not verified: a physical iPhone, shrunk (R8) Android builds on a phone (they pass on the emulator), a MAUI head, Unity and a running Electron app. Those SDKs are tested as libraries on the host machine. Untested source: packages/sdk-kotlin (coroutine wrapper over the Java SDK) and packages/sdk-tauri (Rust crate + Tauri 2 plugin) have never been compiled — no Kotlin or Rust toolchain was available. Their own tests exist but have never run. Not built: an on-device bundle loader for Expo (managed) / Capacitor / NativeScript; Electron app.asar and Tauri frontend hot-swaps; C++/Qt SDK; Expo Updates protocol; Addressables hosting for Unity; publishing any SDK to a package registry (the npm release of the CLI, sdk-js and sdk-electron is prepared, see Publishing to npm, but not done).
Phase 7 — Store releases: done (recording) / planned (store integrations)
Done and tested: store builds are recorded by the CLI without uploading (--native); version, build number and app id are read from the built .ipa / .aab themselves (Info.plist; protobuf AndroidManifest checked against an aapt2-built manifest and three real IPAs), with the project files (Flutter, Gradle, Xcode, Expo, .NET, Unity, Electron, Tauri) as the fallback; store links per project (Google Play derived from the package name, flagged as derived); per-release store status (stacklift store status and the dashboard); active devices per version from SDK check-ins; store-only releases can't be deployed. Verified end to end with the real CLI against the API, and in the dashboard.
Not built: talking to the stores. Stacklift can't see store download counts, ratings or review state and doesn't upload to the stores — those need App Store Connect and Google Play Developer API integrations (planned). Store status is whatever you record. Device counts cover only apps that embed an SDK and check in. .apk, MSIX, DMG and EXE are not opened for their version.
Known limitations
- A channel serves one release; deploying a different runtime version warns that devices on the previous runtime stop receiving updates from it.
- The browser uploader handles files up to 100 MB (WebCrypto cannot stream); use the CLI for larger artifacts.
- The local storage driver and its same-origin proxy are for development.
- Browser/UI verification so far is by build, typecheck and API-level tests; there are no Playwright tests yet.
Flutter code push (Dart code over the air)
Not built. A spike found it is technically possible as a Shorebird-compatible server, but not cleared: Shorebird's Terms neither forbid nor license using their builds with another server, they say they offer no self-hosting, and the protocol can drift.
Over-the-air layers for native and Flutter apps
Built: the script-bundle kind and script-update mechanism on the server, the CLI and the dashboard, the Swift runtime (staged scripts, apply on next launch, crash rollback, JavaScriptCore sandbox) and the Flutter runtime (packages/sdk-dart state machine, packages/sdk-flutter-scripts interpreter adapter) and the Android runtime (packages/sdk-android, QuickJS with memory and time limits). Not built: the C# runtime, and on-device loaders for Expo and Capacitor. (React Native code push is built, see Phase 4; remote UI is built, see Server-driven UI below.) See ota-layers.md.
Server-driven UI
Built: the open stacklift-ui/1 format (JSON Schema, validator, reference resolver, shared fixtures), server validation before signing, stacklift ui validate / ui export (eject to SwiftUI or Flutter), the ui-layout release type with a per-kind update check, SwiftUI, Jetpack Compose, Flutter and React Native renderers with next-launch apply, rollback and fallbacks. Verified on the iOS simulator and an Android 17 emulator in the demo apps, and on a physical Android 16 phone (Compose and React Native demos). Dashboard editor: outline with drag and drop, live phone preview, property forms, sample data, checks, publish as a release, export to code. Not built: a Home Screen widget (WidgetKit) renderer, MAUI and Unity renderers, eject to Compose or React Native code, a run on a physical iPhone, shared drafts. See server-driven-ui.md.