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](https://github.com/project-robius/robrix) began as a flagship application test case and driver for the cross-platform development of [Makepad](https://github.com/makepad/makepad) and [Robius](https://github.com/project-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.
Licensed to the public under https://creativecommons.org/licenses/by-sa/4.0/