Build Android apps using Rust and Iced
github.com136 points by rekireki 15 hours ago
136 points by rekireki 15 hours ago
Some time ago I decided to try building an Android app using Rust. After a few weeks I got it working. There was a new iced release recently, so I've just updated the example to new iced and wgpu. I'd like to share my experience to attract more attention to Rust on Android.
First things, I want to thank all the people who work on the foundational crates and tools such as: - https://github.com/rust-mobile/android-activity - https://github.com/jni-rs/jni-rs - https://github.com/gfx-rs/wgpu - https://github.com/rust-windowing/winit - and many others
When I started I had to learn what tools and examples already exist. Luckily, there's a good set of examples using both NativeActivity and GameActivity: https://github.com/rust-mobile/rust-android-examples
The basic approach is that we take android-activity, winit and wgpu and that's it. On top of that you can find a few egui examples in the rust-android-examples repo.
Alright, so after I've got the basic examples running, I wanted to combine them with iced. Iced is a crossplatform gui library focusing on desktop and web. The mobile support is explicitly a non-goal, as far as I can tell at the moment of writing. Yet, there's an issue where some people posted their experiments. That's how I knew it was possible: https://github.com/iced-rs/iced/issues/302
There's a way to integrate iced in wgpu applications, so called integration example: https://github.com/iced-rs/iced/tree/0.14.0/examples/integra...
Above I mentioned that using winit and wgpu in combination with android-activity is enough to build the app. Putting together 1 + 1 I got 2: let's use iced integration example with android-activity. It was quite easy to compile with almost no errors. First issue I encountered is that there was no text rendered. I solved this by loading fonts the way it was shown here: https://github.com/pop-os/cosmic-text/issues/243#issue-21899...
Then I patched a few widgets to add touch support. And that's it. My role here was to take all the prior work and combine it together in a way that there's a working example.
Some other ways of building Android apps using Rust: - xilem has an explicit goal to support mobile https://github.com/linebender/xilem - egui supports mobile https://github.com/emilk/egui - game engines such as Fyrox and Bevy support mobile: - https://github.com/FyroxEngine/Fyrox - https://github.com/bevyengine/bevy - pretty much anything built on top of winit and wgpu
All of the above is related to building native apps using either NativeActivity or GameActivity. I'm leaving webview out of scope of current post.
What about iOS? As far as I know it should be similar or maybe simpler compared to Android. I haven't built it yet, but the next time I have a sizeable amount of free time, I'll try to make it work. The plan is the same: pick winit, wgpu, iced integration example, mix it together until it works. It'll require the same trick to load fonts, and maybe something else, but no visible blockers as of now.
Once again, thanks to all the people who made it possible and I wish you have a great time building mobile apps with Rust!
This is technically impressive but I'm skeptical about real-world adoption. The fundamental question is: what problem does this solve that Kotlin + Jetpack Compose doesn't? Compose already has declarative UI, excellent tooling, and first-party support. Rust's memory safety benefits matter less in app-land where performance bottlenecks are typically network I/O or image processing, not memory management. The compelling use case would be sharing business logic between iOS/Android/desktop/web. If you can write core logic in Rust once and have thin UI layers per platform, that's valuable. But Iced's UI abstraction needs to be good enough that you're not fighting platform-specific behaviors constantly. Flutter tried this approach and succeeded commercially but still gets criticized for "not feeling native" on either platform. Performance is where this could shine. Rust + Iced should theoretically have lower memory overhead and faster startup than the Kotlin runtime + Compose. For apps that manipulate large datasets locally (photo editors, video editors, CAD tools), avoiding GC pauses matters. But for typical CRUD apps that are 90% API calls and list scrolling, I doubt users would notice the difference. The real barrier is developer experience. Kotlin has incredible IDE support via IntelliJ/Android Studio, instant hot reload, comprehensive documentation, and thousands of libraries. Rust's mobile tooling is immature by comparison. Unless you're already a Rust shop building a performance-critical app, the learning curve probably isn't justified. I'd love to be proven wrong though - more competition in the mobile development space would be healthy. Will apps built with this framework be compatible with accessibility features? No. Iced has no accessibility support built in. It's a pretty hard thing to do, so it's not surprising that something more hobby driven doesn't have it. There is a huge amount of potential for shared infrastructure for "native integrations" for Rust UI projects. Think: React Native modules but in Rust. I'm hoping this can be a reality sooner rather than later. But we're definitely lacking in manpower willing or able to work on the more foundational pieces. Winit in particular is sadly undermaintained. 1 or 2 people working full time on Winit and/or other platform integration pieces would do wonders for the ecosystem. If you do it via React Native turbo modules, it is already possible, either using craby (1) or using uniffi-bindgen-react-native (2). My understanding is that this only gives you access to C++ TurboModules? Binding to C++ is already easy in Rust (and odten Rust itself is a better choice for these "cross-platform business logic" kind of modules anyway). The value here is in unlocking bindings to the native platform APIs (which are mostly Java/Kotlin/Objc/Swift) I would love to see RustActivity in Android one day, this would make the life much easier. There is https://github.com/rust-mobile/android-view, although it's not currently being actively developed. I have no idea why people would want to write UI in Rust when Swift, Kotlin and Dart are much better suited for the job. At least for me: * I don't trust Swift on Android to be well supported, either now, or in the future. I would never want to rely on something Appley on a non Apple platform * I dislike Swift and find it to be an unpleasant language. This is personal pref of coures, just like preferred flavors of ice cream * Dart looks interesting and like a good option, though I don't want to learn a new language and Dart doesn't appeal to me because it feels like they took javascript and made it more like Java, and Java is in about the middle of my list of preferred langs (see above comment about preferred flavors of ice cream). Flutter is a killer app though and might be enough to sway me. * Kotlin is a nice language, though not nice enough to where I'd want to use it outside of Android. The ties to the JVM-world tooling/dependency management is very offputting to me. Overall I have a strong desire to use my preferred language(s) for everything if possible, so things like this are quite attractive to me for that reason. Now that said, when I write Android apps right now, what I typically use is Kotlin or Java because I've found I always end up having to write at least part of the app in those, so might as well keep it simple and consistent in one lang. But I'm always on the lookout! One of the reasons for me personally is a rich selection of packages from crates.io. For example if you are writing a server in Rust, and use something like https://crates.io/crates/reqwest for http requests, then you can reuse it in your mobile app. Also there's serde. You don't need to write the schema for your data if you have Rust on both server and client. Just make a shared crate and use serde to encode/decode the data. It really saves a lot of time if you don't have to use swagger or similar tools. And there's a documentation out of the box with `cargo doc` I mean cross platform is just "heavy work" in general many company literally just give up use web wrapper instead because its just so much work Also on this topic I want to make a shout out to slint.dev !
(I've fiddled with it, and the syntax is extremely easy to grasp - very react-ish). Can use Rust/C as a binding language, and you can even choose the rendering engine (for example QT). +1 for Slint! I worked with it for a while and enjoyed it quite a lot. Florian was working on a more glossy compinent library, not sure what has been made of it. The DSL was pleasant but still had some rough edges. I think they made some nice QoL improvements in the latest releases, but I've not kept up with it. The compile times were quite something, though you can use the previewer tool to prototype faster. Definitely worth giving Slint a shot, they learnt a lot from QML imo How does the text input work there? Does it support IME? Were you able to switch to non-latin keyboards? I think it is handled by the OS (backend renderer) https://docs.slint.dev/latest/docs/slint/guide/backends-and-... But, I have only used it with Romanian and English. Try here: https://slintpad.com/. (just replace the Text with TextInput) and see if it works. slintpad.com uses the wasm port to run on a browser and is not the same as when using Slint to build a "native" app, especially on mobile. Slint does support decent text input and IME. Including text selection with the native handle. As a demo for android you can try the demo from https://material.slint.dev/ ("Download APK") How does this compare for you with slint and dioxus? Dioxus uses web views but still a small app (based on Tauri which uses the OS web view instead of shipping the browser) and slint is native, but may have some slightly more unique license terms than typical Rust projects. Dioxus is WebView, as you've mentioned. Though there's an experimental native renderer mentioned in the README, I would keep an eye on it. And slint should be the same kind of solution as I wrote about. When building native apps for Android, there's usually an issue with text inputs. NativeActivity doesn't support IME, and GameActivity is supposed to solve this. So in case of slint, I would check how they solved the text inputs. > So in case of slint, I would check how they solved the text inputs. Slint uses the NativeActivity by default, but it supports IME by implementing the IME support in Java in the Slint's android backend. > Though there's an experimental native renderer mentioned in the README, The native renderer should be available in 2026! (technically it's available now as a preview, but I wouldn't recommend using it until after the next release) Is there a reason you didn't mention Dioxus (other than not being familiar with it)? It explicitly has Android support as a goal, though (like all Rust GUI crates) it's a work in progress. I made a very simple app with it that works well in an Android emulator, I haven't tried actually side load it yet. I left WebView based solutions out of scope. As you can see, I'm focusing on NativeActivity / GameActivity in my post. Though WebView brings you interesting options. For example, iced is inspired by Elm, and with Dioxus you can use Elm to build mobile apps. Dioxus has this idea stuck that it's webview only. They're actively working on (and ship at least in some form of alpha or beta) a native-renderer backend. Dioxus is a very different API model, being an implementation of the Elm architecture. It’s really comparing apples to octopuses. Iced is the Elm architecture. Dioxus is more akin to modern React/whatever you want to call it. This matches my experience too. Rust really shines once the app grows beyond simple flows. The upfront friction pays off later when debugging and concurrency issues would otherwise start piling up. You gotta check Crux: Cross-platform app development in Rust Crux seems interesting to share app logic between platforms but I don't see how it helps actually render something. Don't you still need a gui framework that supports android or ios? Having spent time around cross platform rollouts and development I think something like Crux is the best approach. Building a complete UI framework to rival what iOS and Android provide natively is a monumental task. Android is in limbo, we need better free open source alternative. The Android Open Source Project is awesome. It's not hard to compile it yourself and run it on a pixel 9. The issue is the hardware imo. (And some of the apps in AOSP really suck, but the actual OS is great imo) The userspace being tied to the JVM is a massive pain. Certainly it's a lot harder to bind to than any other OS's system libraries. How so?? JVM bytecode should be much easier to bind to, as the existence of JVM alternative runtimes for nearly every language shows. Unless you're using a language that's specifically compile-to-jvm (e.g. Java, Kotlin or similar), almost nobody is using those JVM alternative runtimes. They're usually second-class runtimes that don't run the entire ecosystem of the target langauge. React Native runs JavaScript in a separate JS VM, Flutter is compiling Dart to native code with emdedded runtime, and Rust UI code also compiles to a native binary. The "lingua franca" for language bindings is the C ABI which every other OS's platform libraries (Win32/Cocoa/GTK) support. Account created one hour ago just to make this comment. Make it on your real account. Have you considered that people may join HackerNews who were not already on it? Also usernames/handles can be surprisingly hard. It seems reasonable to me that people would pick something related to what they are thinking about at the time. Super impressive, can you link to this post in that issue? I'd like to try iced, but switched to egui on the official Android support. Does this support native components like camera access and stuff like that? I've learned with most libs like this I never have access to the android internals (Flutter as an example) and I'll always have to fallback to writing Kotlin components with broadcast channels or whatever. It doesn't, and I had to write some Java to support clipboard. I see, still a really cool project! Is accessing the internals simply not possible or just really hard to pull off programmatically? I am wondering about that because I never found anything in the android space to enable that without resorting to Kotlin/Java components. It's limited to what NativeActivity / GameActivity can provide. And as @nicoburns mentioned, you'll have to use FFI if you want to access some Android functionality. But it doesn't always go smooth. For example, all my attempts to fix issues with software keyboard didn't work. You can call into to the JVM via FFI (e.g. using the jni crate in Rust), but it's not very nice. And most of the abstractions people have written thus far seem to be primarily (or solely) targeting the "Java calls into native code" use case rather than the "native code calls into Java" use case. I'd love to see something better here. I suspect it's possible. Not downplaying your project but a general related question. What's the deal with writing non-real-time application software in Rust? The stuff it puts you through doesn't seem to be worth the effort. C++ is barely usable for the job either. A lot of complex GUIs are written in C++ (or are thinish wrappers around an underlying toolkit that is C++). This is often for performabce and/or resource consumption reasons. UIs may not have hard realtime requirements, but they are expected to consistently run smoothly at 60fps+. And dealong with multiple screen sizes, vector graphics, univode text,r etc can involve a lot of computation. Rust gives you the same performance as C++ with much nicer language to work with. I don’t understand the question. Why would rust be confined to real-time applications? No the question is why you would use a systems language that necessarily lacks certain ergonomics such as automated garbage collection, for writing GUIs. That makes no sense to me either, to be honest. It turns out it is worth the effort. Once you have got past the "fighting the borrow checker" (which isn't nearly as bad as it used to be thanks to improvements to its abilities), you get some significant benefits: * Strong ML-style type system that vastly reduces the chance of bugs (and hence the time spent writing tests and debugging). * The borrow checker really wants you to have an ownership tree which it turns out is a really good way to avoid spaghetti code. It's like a no-spaghetti enforcer. It's not perfect of course and sometimes you do need non-tree ownership but overall it tends to make programs more reliable, again reducing debugging and test-writing time. So it's more effort to write the code to the point that it will compile/run at all. But once you've done that you're usually basically done. Some other languages have these properties (especially FP languages), but they come with a whole load of other baggage and much smaller ecosystems. > So it's more effort to write the code to the point that it will compile/run at all. But once you've done that you're usually basically done. Not if I don't know what I'm doing because it's something new. The way I'm learning how to do it is by building it. So I want to build it quickly so that I can get in more feedback loops as I learn. Also I want to learn by example, so I actually want to get runtime errors, not type system errors. Later when I do know what I am doing then, sure, I want to encode as much as I can in my types. But before that .. Don't get in my way! Yeah it is a fair point that runtime errors are sometimes easier to understand than compile time errors. They're still a much worse option of course - for the many reasons that have been already discussed - but maybe compile-time errors could be improved by providing an example of the kind of runtime error you could get if you didn't fix it (and it hypothetically was dynamically typed). Perhaps that would be easier to understand for some people or some errors. There's a (Curry-Howard) analogue here with formal verification and counter-examples. [flagged] > René did have to ban an angry troll, whom he mentions in a YouTube comment as one possible perpetrator. Others think someone from the Rust (programming language, not video game) development community was responsible due to how critical René has been of that project, but those claims are entirely unsubstantiated. So what do we think is more likely here? Jumping the gun due to your own dislike of some groups it seems. Perhaps you could refrain from slandering Rust proponents without any evidence. Just in time for google to block sideloading and blocking new apps unless you pay them 6 figures...
yoan9224 - 12 minutes ago
denverllc - 2 hours ago
surajrmal - 2 hours ago
nicoburns - 11 hours ago
foresterre - 7 hours ago
nicoburns - 6 hours ago
rekireki - 5 hours ago
nicoburns - an hour ago
mdhb - 3 hours ago
freedomben - an hour ago
rekireki - an hour ago
tonyhart7 - 8 hours ago
coldstartops - 9 hours ago
Tmpod - 2 hours ago
rekireki - 6 hours ago
coldstartops - 3 hours ago
ogoffart - an hour ago
vlovich123 - 11 hours ago
rekireki - 6 hours ago
ogoffart - 34 minutes ago
nicoburns - 5 hours ago
NoboruWataya - 8 hours ago
rekireki - 6 hours ago
Klonoar - 4 hours ago
adastra22 - 6 hours ago
Klonoar - 4 hours ago
Simplita - 6 hours ago
serial_dev - 11 hours ago
phi-go - 11 hours ago
K0nserv - 5 hours ago
androidinlimbo - 8 hours ago
ChadNauseam - 7 hours ago
nicoburns - 5 hours ago
brabel - 5 hours ago
nicoburns - 4 hours ago
testdelacc1 - 7 hours ago
suddenlybananas - 4 hours ago
freedomben - an hour ago
bbkane - 12 hours ago
zwnow - 6 hours ago
rekireki - 6 hours ago
zwnow - 5 hours ago
rekireki - 41 minutes ago
nicoburns - 4 hours ago
RicoElectrico - 9 hours ago
nicoburns - 6 hours ago
adastra22 - 6 hours ago
amelius - an hour ago
IshKebab - 7 hours ago
discreteevent - 2 hours ago
IshKebab - an hour ago
jbfdrt7t - 12 hours ago
jemmyw - 12 hours ago
winstonewert - 12 hours ago
nubinetwork - 12 hours ago