<h1>Problem Statement</h1>
While working on kiosk software at Zuchiz, I realized that many production issues cannot be solved from the application layer alone.
No matter how well an application is designed, its reliability ultimately depends on the environment in which it runs. In production, there are several factors outside the application’s control that can silently degrade the user experience or even break the entire workflow.
Some common examples include:
<ul>
<li>Unstable or intermittent internet connectivity</li>
<li>Weak or fluctuating power supply</li>
<li>Hardware failures such as storage corruption, memory issues, or peripheral malfunctions</li>
<li>Device-specific operating system issues</li>
<li>Unexpected application crashes or system restarts</li>
</ul>
These problems often surface as application failures, even though the root cause lies much deeper in the system.
Another challenge becomes evident as deployments scale: software updates.
Managing hundreds or thousands of on-premise devices is far more difficult than updating software running in the cloud. Although Over-the-Air (OTA) updates exist, most existing solutions are designed for embedded Linux environments. There are comparatively fewer solutions that provide the same level of flexibility for Android-based kiosks, Android TV boxes, Windows devices, or heterogeneous deployments.
As the number of deployed devices grows, monitoring device health and delivering reliable software updates become operational challenges rather than just engineering tasks. The complexity increases, costs rise, and scaling the business becomes significantly harder.
<h1>The Solution I Wanted to Build</h1>
Earlier this year, I started learning Rust with a different goal in mind. I wanted to migrate an ERP application I had built in Node.js to Rust so that it could deliver better performance while running on cost-effective production servers.
As I learned more about Rust, I realized that performance wasn’t its biggest advantage. What impressed me most was its approach to memory safety, predictable resource management, and its ability to build reliable system level software.
That completely changed the way I thought about solving production problems.
The challenges I had experienced with on-premise devices monitoring hardware health, collecting telemetry, delivering reliable software updates, and continuing to operate even when connectivity was unreliable could not be solved entirely from the application layer. They required software that could interact closely with the operating system while remaining stable over long periods of time.
Rust felt like the right foundation for building that kind of software.
That realization led to the creation of Gunam.
Gunam is an open-source Rust agent designed for managing fleets of on-premises devices. It focuses on three core capabilities:
<ul>
<li>Reliable OTA software updates</li>
<li>Telemetry and system health collection</li>
<li>Offline first synchronization for unreliable network environments</li>
</ul>
The project is designed with reliability as a first-class goal. One of Gunam’s design goals is a panic-safe FFI layer that prevents Rust panics from propagating into the host application, making it easier to integrate Gunam into existing software regardless of the language it was written in.
Gunam is currently Linux first, with planned support for Android and Windows in future releases.
<h3>Gunam is still in its early stages, and I’m currently working toward the first public release.</h3>
The initial version focuses on building a solid foundation with:
<ul>
<li>Operating system detection</li>
<li>CPU, memory, battery, internet, and uptime monitoring</li>
<li>Image-based OTA updates with A/B partitioning and delta update support</li>
<li>A networking layer for telemetry, alerts, and remote session APIs</li>
<li>A panic-safe FFI layer for reliable integration with existing applications</li>
</ul>
This is only the beginning. In future articles, I’ll share the architecture, design decisions, implementation details, and the lessons I learned while building Gunam in public.
If you’d like to follow the project’s progress or contribute, you can find Gunam on GitHub:
GitHub: <a href="https://github.com/IAmInYourKernel/gunam" target="_blank" rel="noopener nofollow">https://github.com/IAmInYourKernel/gunam</a>

Soumyajit Bhattacharya

Gunam is an open-source Rust agent built for managing fleets of on-premises devices, addressing real-world production challenges like unreliable connectivity, hardware failures, and OTA update complexity. The project focuses on three core capabilities: reliable OTA software updates with A/B partitioning and delta support, telemetry and system health collection (CPU, memory, battery, uptime), and offline-first synchronization for unstable network environments. A key design goal is a panic-safe FFI layer that prevents Rust panics from propagating into host applications, enabling integration across languages. Currently Linux-first with Android and Windows planned, Gunam is in early development ahead of its first public release.

Building Gunam: Why Modern Monitoring Should Work Offline First