Mobiler

Build mobile apps in Rust — the logic and the UI — rendered to real native widgets.

Status: experimental. Android (native Jetpack Compose) and iOS (SwiftUI) shells both render the same app core, which also runs on the web (Leptos/WASM — see the full-stack demo). iOS is verified on the simulator. APIs may still change.

Capabilities & plugins at a glance — device/platform features your Rust core calls, all rendered natively:

Built in: HTTP · storage · clipboard · share · browser · toast · device · haptics · confirm · photo · camera

Plugins (mobiler plugin add): 🔎 scanner (barcode/QR) · 🔐 biometric (Face ID/fingerprint) · 🗝️ securestore · 🔌 websocket · ⇅ transfer (streaming upload/download) · 🔔 notifications · 🔋 battery · 📶 connectivity · 📄 filepicker · 📁 files (read/write/download/export) · 📍 geolocation · 🛰️ geolocation-fused (Play Services) · 📇 contacts · 📅 calendar · 🎙️ audio · 📐 sensors · ✉️ composer · 🗣️ tts · ⭐ review · 📤 sharefile · 🎬 video · 🎤 speech · 🗃️ sqlite · 🔵 bluetooth · 🔑 oauth (OAuth/OIDC login) · 📲 push (APNs/FCM, experimental) · 🔥 push-firebase-only (FCM everywhere) · 💳 iap (StoreKit/Play Billing) · 🗺️ geofence (background geofencing, experimental) · ⏰ background-fetch (periodic wake, experimental) · 📊 analytics (Firebase Analytics + Crashlytics, experimental)

→ Built-in capabilities · Plugins

Mobiler builds on Crux: a Rust core owns all state, events, and business logic — none of it in the native layer. On top of that, a Mobiler core's view returns a fixed Widget tree, and a thin, app-agnostic shell renders that tree to real platform widgets. Events flow back into the core as typed messages.

The shell is generic: it's built once from a fixed wire ABI and renders any Mobiler app — no per-app native code, no per-app UI codegen. That's the whole idea:

• Android → Jetpack Compose → Material 3 (shipped)
• iOS → SwiftUI (simulator-verified)
• Web → DOM via Leptos/WASM (the mobiler-web shell — demonstrated in demos/fullstack-todo)

…all driven by the same Rust core.

use mobiler_core::*;
use serde::{Deserialize, Serialize};

#[derive(Default)]
struct Counter;

#[derive(Serialize, Deserialize, Clone)]
enum Msg { Increment, Greet }

#[derive(Default)]
struct Model { count: i32 }

impl MobilerApp for Counter {
    type Event = Msg;
    type Model = Model;

    fn update(&self, msg: Msg, model: &mut Model, cx: &mut Cx<Msg>) {
        match msg {
            Msg::Increment => model.count += 1,
            // Device APIs are capabilities — here the built-in toast.
            Msg::Greet => cx.toast("Hello from Rust!"),
        }
    }

    fn view(&self, model: &Model) -> Widget {
        column(vec![
            title("Counter"),
            text(format!("count: {}", model.count)),
            row(vec![
                button("Increment", ButtonStyle::Filled, Msg::Increment),
                button("Toast", ButtonStyle::Outlined, Msg::Greet),
            ]),
        ])
    }
}

/// The shell renders this — `Event`/`ViewModel` are the fixed Mobiler ABI, so the
/// native shell stays generic and is built once for every app.
pub type App = MobilerShell<Counter>;

You write typed Msg events, a Model, and a view built from widget builders. Mobiler serializes events into opaque tokens behind the scenes; the shell never sees your app's types.

• Generic shell — one prebuilt shell renders any app; adding a platform = writing one shell, not one-per-app.
• Capabilities = plugins — device APIs (clipboard, share, HTTP, …) are async effects fulfilled by the shell's plugin registry; adding one never changes the wire ABI, and an unknown plugin degrades gracefully. See Built-in capabilities.
• Navigation — a core-owned Nav stack drives animated push/pop and the system back button.
• Theme-as-data — e.g. dark mode is a value in the Widget tree; the shell themes the whole app from it.

The Widget vocabulary renders identically on Android, iOS, and web:

• Layout — rows, columns, grids, cards, scrollers, paged lists (LazyList — infinite scroll + pull-to-refresh), boxes, spacers, dividers.

• Inputs — buttons, text fields, toggles, segmented controls, search fields, rating.

• Navigation — Scaffold with a top bar, bottom tabs, a FAB, and bottom sheets (it goes adaptive on tablets: a side rail + capped width).

• Media & feedback — images, avatars, progress bars, shimmer skeletons, swipe actions, long-press on cards (press-and-hold for a secondary action), an inline month calendar, an in-app PDF viewer (PdfView — display a backend-generated report), a controllable video player (Video — AVPlayer / Media3 / <video>; HLS + MP4; app-driven play/seek + position/ended, plus poster, start-offset, captions, playback rate/volume, full transport state, a playlist/queue, Picture-in-Picture, and hls.js for web HLS on Chrome/Firefox), and an embedded web view (WebView — WKWebView / Android WebView / <iframe>; hosts any page or a hosted player embed like Bunny.net, with a mobiler_core::bunny URL helper), and an interactive map (Map — iOS MapKit / Android MapLibre / web MapLibre-GL, no API key; app-driven center/zoom + markers, with map/marker taps reported back via input).

• Charts — Chart in eight styles: bar, line, stacked bar, 100%-stacked bar, pie, donut, concentric fitness-style progress rings, and a radial gauge — multi-series with an optional y-axis and legend. Plus a variable-width stacked-region / coverage-gap RegionChart for value-band visualizations.

• Accessibility — wrap any widget with a11y(child, label) (+ with_a11y_hint / with_a11y_role) to name it for a screen reader (VoiceOver / TalkBack): iOS accessibilityLabel/traits, Android contentDescription/role, web aria-label/role. Text honors the OS font-size setting on all three.

  // a two-series weekly bar chart with axis + legend
  chart(
      vec![ChartSeries::new("Alex", vec![1.0, 2.0, 3.0]),
           ChartSeries::new("Sam",  vec![1.0, 1.0, 2.0])],
      vec!["Mon".into(), "Tue".into(), "Wed".into()],
      ChartStyle::StackedBar, /* axis */ true, /* legend */ true,
  )

Device APIs are capabilities — async effects the generic shell fulfils natively on all three platforms (Android, iOS, web), reached through typed cx helpers in your update. These ship in the shell out of the box:

Each maps to an opaque {plugin, op, input} effect, so adding a capability is a shell-registry entry — it never changes the wire ABI or the generated bindings.

Advanced/native capabilities ship as droppable plugins: one command installs the native handler into your app and patches the per-shell registration — no framework code, no ABI change. Bundled free plugins:

mobiler plugin list            # see the bundled (free) plugins
mobiler plugin add scanner     # install one into the current app

Call a plugin from Rust via the generic escape hatch — cx.plugin("scanner", "scan", "", then) → PluginResponse { ok, output }. A plugin is a self-describing package (mobiler-plugin.toml + native sources); mobiler plugin add also accepts a local package directory, which is how commercial/licensed plugins (e.g. NFC) are delivered.

Mobiler is production-bound. On top of the built-in capabilities and plugins above, these are planned (order is demand-driven; feedback and contributions welcome):

• Animations / view transitions
• On-device hardening of the experimental plugins (push / iap / push-firebase-only / geofence / background-fetch / analytics)

Recently shipped: card long-press (with_long_press(card, E) — a press-and-hold action on any Card, alongside its tap; web pointer-hold / iOS onLongPressGesture / Android combinedClickable), FusedLocation (mobiler plugin add geolocation-fused — higher-accuracy device location via Play Services FusedLocationProvider; a drop-in alternative to geolocation), BLE write + notify (the bluetooth plugin gained a write op + a characteristic-change notify stream), maps (Map — an interactive map with markers + tap events; iOS MapKit / Android MapLibre / web MapLibre-GL, no API key; app-driven center/zoom, taps reported via input), accessibility (a11y(child, label) + with_a11y_hint/with_a11y_role — name any widget for VoiceOver/TalkBack; iOS accessibilityLabel/traits, Android contentDescription/role, web aria-label/role; + dynamic-type/font-scale honored on all three shells), analytics + crash reporting (mobiler plugin add analytics — Firebase Analytics + Crashlytics: events, user props, automatic crash capture; experimental), background geofencing + periodic wake (mobiler plugin add geofence / background-fetch — native-scheduled monitoring → local notification + buffered event on next foreground; experimental), two-pane master-detail (Split — list + detail side-by-side on tablets/landscape, push-nav on phones), app files (files plugin — read/write/list, download a URL to disk, export to Files/Downloads), deep links + app lifecycle (the built-in system stream — cx.subscribe("system","system","events",…) delivers inbound deep-link URLs [custom scheme, default = the app's bundle id; a launch link is buffered until the core subscribes] and foreground/background events; iOS .onOpenURL+scenePhase / Android intent-filter+onNewIntent+lifecycle / web URL+visibilitychange), Video v2 (Video grew poster + start-offset, sidecar/embedded captions, playback rate & volume, full transport state via suffixed input ids, a playlist/queue with auto-advance, Picture-in-Picture [iOS PiP background continuation is a one-line per-app UIBackgroundModes: [audio] opt-in], and hls.js for web HLS on Chrome/Firefox), rich form fields, the oauth plugin (OAuth 2.0 / OIDC login), locale-aware number / currency / date formatting (mobiler_core::format — Swiss/CHF, de/fr/it, en, Serbian/RSD), a device-locale getter (cx.device_locale, iOS/Android/web), an in-app PDF viewer (PdfView — iOS PDFKit / Android PdfRenderer / web <iframe>), and a native → core streaming primitive (cx.subscribe/unsubscribe — a source pushes N events over time into update; iOS/Android/web, with a built-in ticker), a paged feed list (LazyList — infinite scroll + pull-to-refresh, app-owned loading state), remote push (mobiler plugin add push — APNs/FCM, device-token registration + an inbound event stream; experimental), in-app purchases (mobiler plugin add iap — StoreKit 2 / Play Billing: products, purchase, restore, a transactions stream; experimental), a Firebase-everywhere push variant (mobiler plugin add push-firebase-only — FCM on both platforms via the Firebase iOS SDK, one token + one backend; experimental, alternative to push), a controllable video player (Video — AVPlayer / Media3 ExoPlayer / <video>: HLS + MP4, app-driven play/seek + position/ended events), and an embedded web view (WebView — WKWebView / Android WebView / <iframe>; hosts any page or a hosted player embed like Bunny.net, with a mobiler_core::bunny URL helper).

Monorepo for now. Each demo under demos/ is a self-contained project (its own workspace, like mobiler new produces) — so any can be extracted to its own repo.

Same core, every platform. The coffee storefront — one Rust core, the same Widget tree — rendered by the stock Android, iOS, and web shells, no per-platform UI code:

Android (Jetpack Compose)	iOS (SwiftUI)	Web (Widget→DOM)

And the full-stack demo shows that same core rendered natively and as a web app, both backed by one Axum server:

Android (Compose)	Web (Widget→DOM)

See demos/fullstack-todo, demos/todo, and demos/coffee.

One core, one Widget tree — with_theme(...) gives each app its own brand (seed color, corner radius, font, density), and the widget set covers real product UI: icon tab bars, a floating action button, cards, star ratings, avatars, horizontal carousels, segmented controls, search fields, and bottom sheets — plus native capabilities like cx.pick_date / cx.pick_time.

Fade House (demos/barbershop) — a barbershop booking demo: a brass-on-dark brand, an icon tab bar + FAB, a brand-gradient promo banner, an avatar rail with ratings, and a tap-to-book bottom sheet with a date → time → confirm flow.

Home — web	Home — iOS (native)	Booking sheet — web

The same stock shells, re-themed — coffee with a terracotta brand, todo with indigo — no shell code changed, just a Theme value:

coffee (terracotta)	todo (indigo)

You'll need the Rust toolchain (with Android targets), the Android SDK/NDK, and an emulator or device.

cargo install mobiler        # or, from this repo: cargo build -p mobiler
mobiler doctor               # check your host has everything
mobiler new myapp            # scaffold an app (Rust core + generic native shells)
cd myapp
mobiler dev                  # build core → generate types → build APK → install + launch
#   mobiler watch            # …and rebuild on every change

Edit shared/src/app.rs (your MobilerApp) and re-run mobiler dev.

Building with a coding agent? Add --agentic to mobiler new to drop a CLAUDE.md guide into the scaffold so e.g. Claude Code writes idiomatic Mobiler. Bare --agentic assumes a mobile app talking to any API or storing data on-device; tailor it with --agentic shared-ui (same UI on mobile + web) or --agentic api (reusable core + JSON API backend).

On a Mac, the scaffold also includes an iOS shell — bash iOS/build-ios.sh builds it for the simulator (needs Xcode + XcodeGen; no Apple account or signing required).

The generic native shells (the Widget-tree interpreter on each platform) are scaffolded into your project, so a new framework version's shell improvements don't arrive by bumping a dependency. mobiler upgrade pulls them in, from the app root:

cargo install mobiler   # get the newer CLI first
cd myapp
mobiler upgrade         # 3-way merge; review results as *.mobiler-new
mobiler upgrade --apply # …or write the merged shells in place (a *.mobiler-bak is saved)

True 3-way merge. mobiler new snapshots the pristine shells into .mobiler/base/ (the merge ancestor), so upgrade can reconcile three versions per file — the ancestor, your current file, and the new template — exactly like git merge. Framework improvements apply and your edits and plugin injections are preserved; only genuinely overlapping changes become a conflict, written as <file>.mobiler-new with <<<<<<</>>>>>>> markers (never auto-applied). It never touches your Rust app code (shared/src/). It also bumps your mobiler-core dependency. By default a clean merge is offered as <file>.mobiler-new; --apply writes it in place after saving a .mobiler-bak. Commit .mobiler/ so the baseline (and version stamp) travel with the repo. Apps scaffolded before baselines existed fall back to a conservative reconcile and get a baseline written for next time.

Dual-licensed under either of MIT or Apache-2.0, at your option.