Robrix: a pure Rust multi-platform Matrix client, and a peek at its future
Robrix is a "new" FOSS Matrix client written entirely from scratch in Rust, with some cool power user features like a dockable-tabs view of multiple rooms side-by-side, just like your favorite IDE. It's simple and flexible enough for casual chatters as well, and can seamlessly transition into a sleek mobile-friendly adaptive UI for narrow screens.
Robrix runs smoothly and consistently across mobile & desktop platforms, thanks to the underlying Makepad UI toolkit and Robius abstraction crates, which we also wrote ourselves in Rust. After several years of hard work on those components, we have finally reached the milestone of publishing Robrix to major app stores.
Join us to learn more, see some fun live demos, and give it a try yourself. We'll also preview some of our future ideas, such as making Matrix the best medium for coordinating and managing multi-agent workflows (even better than Telegram!).
Robrix began as a flagship application test case and driver for the cross-platform development of Makepad and Robius, but has since become a real project in its own right. While it's not yet 100% complete, we've achieved near feature parity with other big Matrix clients, and that gap is closing every week.
First half: current state + demo
In the first half of this talk, we'll give an overview and live demo of Robrix's current design and core Matrix functionality. Beyond the goals of flexibility and productivity for users who want it, we also prioritize consistency: all UI experiences and features are available on every device and every platform – we don't restrict features just because you're on your phone.
While Robrix itself is platform-independent (aka, easy to contribute to! 😊), it runs natively on iOS, Android, macOS, Windows, and Linux (X11 & Wayland). Web/WASM and HarmonyOS/OpenHarmony are mostly supported but need a bit of TLC. Importantly, since we control the entire stack, we can achieve deep integration with underlying OS services and platform features, all without a heavyweight framework or web engine like Electron. Integration layers can even be customized, allowing us to improve upon known limitations of other frameworks like Flutter.
Publishing Robrix to app stores has also validated our earliest objective: one can successfully distribute cross-platform Rust apps through platform-native channels despite bypassing those platforms' native UI frameworks and build systems.
Second half: future & in-progress work
In the second half of this talk, we'll explore some potential future directions. One example is leveraging Matrix as the medium for coordinating and managing multi-agent workflows, which are becoming increasingly popular. We envision an agent being able to generate or download dynamic "mini-apps" written in Splash, Makepad 2.0's UI scripting language, that can be safely interpreted in a streaming manner within a resource-isolated sandbox.
This would enable an agent to create things like a custom interactive status dashboard directly within a room, which would be accessible on any device, even restricted systems like iOS. We could even inject custom dependencies, such as the Matrix Widget API, into a custom Splash mini-app to enable it to access room info, user context, and timelines with the existing capability-based permissions model.
This combination of Robrix's rich UI and the Matrix Widget API could elevate Matrix to become the ideal choice for agent coordination, surpassing Telegram, the de facto choice for chat-room-like coordination between agents.
Beyond that, we'd also like to experiment with integrating on-device models for simpler, more practical utility features, e.g., summarizing a few weeks of missed messages in an E2EE room (preserving privacy) or answering user questions based on room history.
I'm a huge fan of Matrix, Rust, systems development, safe programming languages, and all things open source. I'm the creator and main dev of Robrix, a big contributor to the Makepad UI toolkit, and the tech lead of Project Robius. I also heavily use (and unwittingly test out) the matrix-rust-sdk. I was honored to be a part of the first Matrix Foundation Governing Board.
I'm currently a principal engineer at Futurewei Technologies and live in the Seattle area with my wife and (very old) pup, though I'm originally from Texas. Off the clock, I'm mostly into playing jazz, going backpacking in the wilderness, and otherwise recouping lost time from spending wayyy too long doing a PhD.