Mecha Comet:
Interaction System Architecture
A comprehensive, fully open-source handheld Linux-based device running MechanixOS (Fedora-based). I worked across the stack — from Rust-powered system services and gRPC APIs to the high-fidelity UI layer — bridging real-time device hardware with seamless cloud-based authentication.
Operating System Interface Implementation
Built and integrated system-level UI for MechanixOS (Fedora-based), mapping gesture-driven inputs to underlying OS services. Developed reusable components using EGUI (Rust), ensuring performance and interaction consistency across handheld system modules.
Universal Search
Search across apps, files, and system utilities
Navigation Hub
Swipe up from right for Settings drawer, Swipe up from left for Notifications
App Drawer
Browse and launch installed applications
Interaction Logic:
Trigger & Response System
The control system uses contextual expansion. Tapping a grid element triggers a modal response that maps back to the interaction origin, maintaining user orientation through spatial consistency.
Control Grid Origin
Tapping a control tile (e.g. Wireless) identifies the 2D coordinate origin for the modal expansion.
Contextual Modal
The modal expands from the origin. Closing it resolves the animation back into the specific tile, closing the loop.
System User interface Integration
This coordinate-driven logic isn't just an animation — it informs the entire OS gesture language. By mapping raw pointer inputs to grid-aligned origins across MechanixOS, we create a system that feels "alive" and responsive to user intent.
Interaction Origin Logic (Vector Space)
"Indicates this position as center point of pop up modal that we want to show from (0,0) origin"
Live Coordinate Resolution
Coordinate Origin Logic
The demo on the left illustrates how we resolve interaction points. This same logic with more refinement drives launcher transitions and system-level gesture controls across the Mechanix OS.
Device interaction captured during threshold testing.
Power-Off: Gesture Threshold
System shutdown is handled through a gesture-based threshold to ensure deliberate user intent. On render, an amber card (with power icon and label) animates from the top and settles at 50% of the screen height.
Interaction behavior:
- →If the user drags the card beyond 50%: trigger downward bounce animation, switch off device
- →If the drag does not cross 50%: return card to original mid-screen position
"Interaction demo from device testing phase"
Connect App: Time-Based
Cloud Authentication
Built the Connect App to link the handheld device with Mecha Cloud services using a time-based authentication flow. The device waits for a user-entered code generated on the cloud platform, refreshing every 60 seconds.
- User enters a 4-digit authentication code generated on the cloud web platform every 60 seconds.
- Implemented device-to-cloud connection flow with real-time validation and session handling.
- Integrated Rust backend services with seamless frontend interaction.
- Connected gRPC APIs using a custom Rust framework (MCTK) with Tokio for async, non-blocking communication.
Built using Rust-based services and async architecture to ensure reliable, real-time device ↔ cloud communication.
This flow reduces friction by keeping authentication simple, while ensuring time-bound security through short-lived user input.
- 01Open cloud.mecha.so
- 02Login to your account
- 03Visit Devices section
- 04Enter the code above
* This is an interactive simulation of the pairing flow
Bridging System Services & UI
D-Bus
IPC Architecture
System-level communication bus syncing device state with UI events.
BlueZ
Bluetooth Stack
Handling bluetooth connectivity and device discovery.
NetworkManager
Connectivity
Managing asynchronous network transitions and live signal state.
Built in the Open
Mecha Comet is part of the Mecha open-source ecosystem. You can explore the full implementation of the shell, system services, and UI crates on GitHub.
Summary
I worked across Rust system services, the UI interaction layer, and the IPC communication bridge for MechanixOS, enabling real device-level interactions rather than simulated UI behavior. Integrating Rust services with eGUI required a deep understanding of asynchronous state management and system protocols.
Working on Mecha Comet allowed me to bridge the gap between low-level system engineering and high-level interaction design. Moving across layers — from D-Bus signals and hardware constraints to user-facing UI and interactive animations — requires a unique understanding of how asynchronous architecture impacts the "feel" of a device.