GitHub —
Beginner 10 min

Supported platforms

See which targets are supported today, what CI proves, and where preview status still applies.

Current support matrix

Desktop and WebAssembly are the supported product targets. Android and iOS use the same models, widgets, layout, text, and WGPU renderer, but remain explicit preview targets until physical-device, assistive-technology, lifecycle, and owner-signing validation is complete.

TargetStatusValidated todayImportant boundary
LinuxSupported · runtime-testedNative gallery, hidden-display interaction, WGPU, accessibility, all featuresSome integrations require Wayland/GTK system packages
WindowsSupported · CI-compiledComplete workspace, native implementation, DirectX 12 and Vulkan fallback pathsPlatform behavior still receives focused release validation
macOSSupported · CI-compiledComplete workspace, AppKit integration, Metal surface, bundle-oriented updater pathSigning and notarization belong to the application owner
WebAssemblySupported · browser-testedWebGPU, browser semantics, responsive live gallery, documentation examplesRequires a WebGPU-capable secure browser context
AndroidPreviewCross-compile, debug APK, release AAB, IME, safe areas, activity progressPhysical devices, TalkBack, lifecycle breadth, and Play signing need validation
iOSPreviewCross-compile, XCFramework, Simulator app, safe areas, IME, ActivityKit bridgePhysical devices, VoiceOver, provisioning, archive signing, and TestFlight need validation

Share the core; keep native edges explicit

Application models, views, fonts, themes, tasks, and renderer configuration belong in a shared Rust crate. Desktop, WebAssembly, Android, and iOS launch that same application through target-specific entry points.

A platform is not considered supported merely because Rust can compile for its target triple. The matrix distinguishes runtime tests, browser tests, compile checks, packaging checks, and preview-only native shells so the claim remains auditable.

Select platform integrations deliberately

Core UI capabilities are selected by Cargo target. Native entry points and integrations such as trays, system dialogs, WebViews, native popovers, desktop backdrops, Android services, and iOS ActivityKit stay opt-in because their dependencies and lifecycle rules differ.

Reference files

These are the implementation and guide files used for this chapter.

README.mddocs/native-mobile.md.github/workflows/ci.yml
Compiled example

The current support matrix rendered by Argui

The Rust file below is imported verbatim by this page and compiled into the WebAssembly application running underneath it.

Open exact source
app_examples/docs-examples/src/examples/platform_support.rs
use argui::{
    runtime::{Context, Render},
    text::TextStyle,
    ui::{Axes, Element, Overflow, ScrollConfig, Sides, length, percent},
    widgets::default_theme,
};

const PLATFORMS: [(&str, &str, &str); 6] = [
    (
        "Linux",
        "Supported · runtime-tested",
        "Native WGPU, input, accessibility, windows, and the complete gallery.",
    ),
    (
        "Windows",
        "Supported · CI-compiled",
        "Native WGPU with DirectX 12 and Vulkan fallback paths.",
    ),
    (
        "macOS",
        "Supported · CI-compiled",
        "Native AppKit windowing, Metal rendering, and desktop integration.",
    ),
    (
        "WebAssembly",
        "Supported · browser-tested",
        "WebGPU rendering, browser semantics, and the complete live gallery.",
    ),
    (
        "Android",
        "Preview",
        "Cross-compilation, APK/AAB packaging, IME, safe areas, and activity progress.",
    ),
    (
        "iOS",
        "Preview",
        "XCFramework/Simulator packaging, safe areas, IME, and ActivityKit progress.",
    ),
];

pub struct Example;

impl Render for Example {
    fn render(&mut self, cx: &mut Context<Self>) -> Element {
        let themes = default_theme(cx.environment());
        let theme = themes.resolve(cx.environment().color_scheme);
        let cards = PLATFORMS.into_iter().map(|(platform, status, detail)| {
            Element::column([
                Element::text(platform).text_style(TextStyle {
                    color: theme.foreground,
                    font_size: 18.0,
                    weight: 700,
                    ..TextStyle::default()
                }),
                Element::text(status).text_style(TextStyle {
                    color: theme.primary,
                    font_size: 13.0,
                    weight: 650,
                    ..TextStyle::default()
                }),
                Element::text(detail).text_style(TextStyle {
                    color: theme.muted_foreground,
                    font_size: 13.0,
                    ..TextStyle::default()
                }),
            ])
            .padding(Sides::length(16.0))
            .gap(7.0)
            .background(theme.card)
            .border(argui::paint::Border::all(1.0, theme.border))
            .radius(argui::paint::CornerRadii::all(10.0))
        });
        Element::column([
            Element::text("Argui platform support").text_style(TextStyle {
                color: theme.foreground,
                font_size: 28.0,
                weight: 760,
                ..TextStyle::default()
            }),
            Element::text(
                "Desktop and Web are supported today. Android and iOS are explicit preview targets.",
            )
            .text_style(TextStyle {
                color: theme.muted_foreground,
                font_size: 14.0,
                ..TextStyle::default()
            }),
            Element::column(cards).gap(10.0),
        ])
        .width(percent(1.0))
        .height(percent(1.0))
        .min_height(length(0.0))
        .padding(Sides::length(24.0))
        .gap(16.0)
        .background(theme.background)
        .overflow(Axes {
            x: Overflow::Hidden,
            y: Overflow::Auto,
        })
        .scroll_config(ScrollConfig::default().scrollbar(theme.scrollbar.clone()))
    }
}
The current support matrix rendered by Argui

Starting this lesson’s WebAssembly module…