Building Android Apps with Rust and Iced Framework

A developer recently shared their successful experience in building an Android app using Rust and the Iced GUI library, updating the example to the latest releases of Iced and WGPU. This initiative aims to draw more attention to Rust's capabilities on Android, leveraging foundational tools like android-activity, winit, and wgpu. Starting with existing examples from the rust-android-examples repository, which support both NativeActivity and GameActivity, the developer combined these with Iced's integration example for WGPU applications.

Despite Iced's primary focus on desktop and web—where mobile support is not an explicit goal—the integration compiled with minimal errors. Key challenges included fixing text rendering by loading fonts via a specific method and patching widgets for touch support. The result is a working example that builds on prior community efforts. Other Rust-based options for Android include libraries like xilem and egui, as well as game engines such as Fyrox and Bevy. Looking ahead, similar approaches could extend to iOS, with no major blockers identified.

The journey to building Android apps with Rust begins with essential crates and tools that form the backbone of native development. Developers can rely on android-activity to handle Android's activity lifecycle, integrating seamlessly with winit for window management and wgpu for graphics rendering. These components provide a solid foundation without needing additional frameworks initially.

Existing resources play a crucial role in getting started. The rust-android-examples repository offers a comprehensive set of demonstrations using both NativeActivity and GameActivity, allowing developers to test basic setups quickly. Additionally, examples incorporating egui are available within this repo, showcasing immediate UI possibilities on Android.

Gratitude extends to the contributors behind these tools, including projects like jni-rs for Java Native Interface bindings and various others that enable Rust's interoperability with Android's ecosystem. This collaborative effort underscores the community's commitment to expanding Rust's mobile footprint.

• android-activity: Manages Android app activities in Rust.
• winit: Provides cross-platform window handling.
• wgpu: Delivers WebGPU-based graphics API support.
• rust-android-examples: Includes practical demos for NativeActivity and GameActivity.

Iced, a cross-platform GUI library primarily designed for desktop and web applications, presents unique opportunities for Android despite mobile not being an explicit goal. Developers have experimented with its integration, as documented in community discussions, revealing pathways to adapt it for touch-based interfaces.

The integration process leverages Iced's example for embedding within wgpu applications. By combining this with android-activity, compilation proceeds smoothly with few errors, enabling a functional GUI layer on top of the core rendering setup.

Key Integration Steps

To achieve this, the basic stack of android-activity, winit, and wgpu serves as the entry point. The Iced integration example then overlays the GUI elements, allowing Rust code to drive both the app logic and user interface.

1. Start with rust-android-examples to verify the base Android setup.
2. Incorporate the Iced WGPU integration example.
3. Compile and test for compatibility on Android devices.

This approach transforms Iced from a desktop-focused tool into a viable option for mobile, building directly on established Rust graphics primitives.

While the integration of Iced with Android proved straightforward in many aspects, certain hurdles required targeted solutions. A primary issue was the absence of text rendering, which stemmed from font loading mechanisms not optimized for mobile environments.

This was resolved by adopting a font loading technique demonstrated in community resources, ensuring proper display of textual elements within the app. Following this, modifications to select widgets introduced essential touch support, adapting the interface for Android's input methods.

The developer's contribution focused on synthesizing these elements into a cohesive, working example rather than pioneering new features. This assembly of prior work— from font fixes to touch patches—results in a reproducible template for others exploring Rust on Android.

• Text rendering fix: Implemented via specific font loading method.
• Touch support: Added through widget patches.
• Overall role: Combining existing solutions into a functional demo.

These adjustments highlight the iterative nature of porting desktop libraries to mobile, where small tweaks unlock broader usability.

Beyond Iced, several Rust-based options facilitate Android app development. Xilem explicitly targets mobile support as a core objective, while egui already accommodates touch interfaces natively. Game engines like Fyrox and Bevy extend their capabilities to mobile platforms, leveraging winit and wgpu for rendering.

Any project built atop these foundational elements can potentially target Android using NativeActivity or GameActivity approaches. Webview-based apps, though outside this discussion, represent another avenue not explored here.

Extending to iOS

Prospects for iOS mirror Android's setup, potentially even simpler in execution. The strategy involves selecting winit, wgpu, and the Iced integration example, then refining as needed—such as the font loading trick—with no apparent obstacles.

Future efforts will prioritize this expansion once time permits, promising cross-platform consistency in Rust mobile development.

In conclusion, the successful Rust and Iced Android app exemplifies the language's maturing ecosystem for mobile. By honoring community tools and addressing integration nuances, developers can innovate efficiently. This progress invites more experimentation, fostering Rust's role in diverse app creation across platforms.