RobustOS Pro

Industrial Linux that puts your applications at the edge

RobustOS Pro brings a full Debian environment to Robustel gateways so you can run containers and native Linux applications next to the process, not just in the cloud. Teams use their familiar Linux tools, libraries, and build pipelines, then deploy on proven industrial hardware with router-grade networking underneath. You start locally on a single device with a clear Web Manager and CLI, standardize the way apps start and persist, and roll forward or back with confidence when you’re ready to scale.

Not sure what IoT Operating System is right for your business, click the button below to speak to a Robustel product specialist today

Software Inquiry

An Industrial Linux Platform Built for Organizations Moving Applications to the Edge

Operations Leaders

Consolidate boxes by running your applications on the Robustel gateway you already trust. Start local on one site, validate performance and recovery, then standardize images and rollbacks so scale is predictable. You get fewer truck rolls and one device to secure, monitor, and support.

Network Engineers

Work with a standard Debian environment while keeping router-grade networking underneath. Pin versions, sign packages, and keep clean upgrade and rollback paths so changes are governed and auditable. RCMS can mirror router workflows at fleet scale; Debian containers and packages remain managed on the device.

Developers & Integrators

Ship containers first, or build native apps with the RobustOS Pro SDK when you need tight integration. Expose settings in the on-device UI, control start-up order and persistence, and use logs and diagnostics to troubleshoot in the field. Port existing Linux code with minimal friction and keep a known-good build for fast rollback.

Why Debian on the Gateway

A standard Linux userland you already know

RobustOS Pro is based on Debian, so devs and integrators can lean on mainstream package managers, libraries, and languages rather than a bespoke embedded stack. That shortens learning curves, speeds up PoCs, and makes vendor hand-offs cleaner because the platform looks and behaves like the Linux your teams use every day.

Built specifically for edge applications, not just routing

Containers and native apps run on the device with explicit control over service ownership, start-up order, and persistence. You decide whether a service is managed by RobustOS Pro (UI/CLI-controlled) or left to a third-party runtime/shell (ideal when you want to treat it like a standard Linux service). Either way, you retain a single point of truth for how the device behaves.

Long service life with a clear security path

Industrial projects live for years. RobustOS Pro follows a 10-year software life-cycle with critical security patches and high-priority fixes available over that horizon; automated security updates are supported when your change-control allows it. That means fewer platform surprises and simpler compliance narratives over time.

Designed to survive edge conditions

Power events, cold boots, and hands-off sites are realities in the field. The filesystem design protects system integrity during upgrades or downgrades and gives you a fast reset-to-default if a build gets messy, so you can always get back to a known-good state without swapping hardware. Flash Manager helps you verify image behavior and flash wear before and after trials.

Developer freedom with structure

Most common languages are welcome (C/C++, Python, Java, Node.js, and more). RobustOS Pro follows the Debian model: from v2.4.0, the system does not enforce app-signature verification. You install from your trusted APT repository or upload a local .deb your supply-chain, your rules. The SDK provides clear hardware interface specifications and integration hooks so releases remain repeatable, documented, and auditable via your change control and RCMS activity logs.

Applications at the Edge — What You Can Run and How It Runs


Start on one device, add the services that matter, and scale when you are ready. RobustOS Pro gives you two clean paths—containers for speed and portability, native apps for tight integration—so IT/OT can choose the right level of control on a per-service basis.

How you run it
  • Containers first. Package data collection, protocol translation, local APIs, or analytics as containers using your existing toolchain. On the device you set resources and environment variables, control start order, and decide whether the service is governed by RobustOS Pro (UI/CLI control) or treated as a third-party component managed by its own tooling. This balances central control with developer autonomy.
  • Native apps with the SDK. The SDK supports two core scenarios:

    (a) Porting & adaptation — bring apps built for general Linux (e.g., Raspberry Pi) onto Robustel hardware. Use the SDK’s hardware interface specs to adapt the I/O layer so your code runs reliably on our platform.

    (b) Integration & customization — when you want unified control through the device’s Web Manager and CLI, perform secondary development with the SDK to expose settings, status, and actions in the UI.
    Install and update via your APT repo or local .deb upload; manage lifecycle with system services and RCMS rings so changes remain reversible and auditable.
  • Port existing Linux software. The environment targets ARMv8 across the Robustel gateway portfolio, so many projects can move from popular single-board computers or small embedded PCs with minimal changes—gaining an industrial chassis and router-grade networking underneath.
What you’ll run (and why)
  • Data collection and protocol bridging. Poll serial or field buses, normalize values, and forward upstream when links allow. You cut hardware, reduce latency, and keep legacy assets talking to modern systems.
  • Local APIs and control services. Expose a small HTTP or gRPC API for site logic or third-party tools so decisions happen on site even during backhaul interruptions.
  • Data reduction and edge analytics. Filter, deduplicate, and score events before sending to the cloud. You save bandwidth and improve response times without changing upstream systems.
  • Event handling and alarms. Trigger actions from I/O, serial, or application states and log outcomes for audit. Local responses stay fast and predictable.
  • LoRaWAN forwarders (on supported models). Forward packets to your chosen network server without adding another box—keeping radio, routing, and applications in one device.

Take your Local Workflow to the Cloud

Everything you do on the device can be mirrored in RCMS with the same menus and logic. Schedule upgrades, push configurations, monitor health, and run diagnostics across one site or thousands without changing how you work locally.

EXPLORE RCMS CREATE A FREE ACCOUNT

Secure Inside & Out

You manage application security on the device; Robustel secures the platform it runs on. The result is a balanced model where local control and external assurance work together.

Secure on the Inside (your controls)

RobustOS Pro ships with a hardened networking stack and policy controls designed for enterprise IT and OT realities. You set access at the edge with firewall zones, role-based administration, and encrypted management paths. 

  • Management access you can lock down. Enable HTTPS and SSH only where needed, tie them to your own certificates, and restrict who can reach the Web Manager or CLI.   
  • Firewall and zones. Control forwarding between LAN, WAN, and other zones; decide whether the device responds to ping; keep a clean separation between segments.   
  • Standards-based VPN. Use IPsec and OpenVPN with your own CAs, keys, and CRLs. The built-in Certificate Manager centralizes files for fast deployment and audit.   
  • Logs and diagnostics for audits. Generate and download system journals and diagnostic bundles to support change reviews and incident response. 
Debian-native hardening (the foundation)

RobustOS Pro is built on Debian for predictable maintenance, signed software delivery, and modern kernel features.

  • Signed package delivery. Debian’s APT uses cryptographic signatures (apt-secure) to verify repository metadata and package integrity before install. 
  • Automated security updates. RobustOS Pro supports automated installation of security patches so fleets can stay current with minimal touch. 
  • Long-term security maintenance. The OS is based on Debian 11 with a ten-year software life cycle that includes critical security fixes, giving teams a stable plan for the long haul. 
  • Role and privilege separation. Granular roles in Web Manager, plus a separate sudo user for Linux shell access, help you enforce least privilege on operations and applications. 
  • Signed app installs via SDK. Your own .deb packages are signed and validated during install, providing a chain of trust for in-house apps. 
  • Secrets and certificates under your control. Import CAs, keys, and PKCS#12 bundles, and encrypt secret data stored on the device.   
Learn More in the Knowledge Base
Verified on the outside (our assurance)


Your team secures the deployment; we secure the operating system that underpins it. Robustel maintains an ongoing program of penetration testing and structured release processes so you can plan with confidence.

  • Independent penetration testing and advisory. RobustOS Pro is assessed by Bulletproof, as announced in our public security partnership. 
  • Regular security releases and documented updates. You get a clear cadence of fixes to core components and transparent release notes. 
Visit our Security Centre

RobustOS or RobustOS Pro?

RobustOS is the standard OS for our routers and modems. It provides secure networking, fleet management, and an SDK for extendability. RobustOS Pro is a separate Linux Debian–based environment for industrial computing and containerized applications. Choose RobustOS for networking control and fleet operations; choose RobustOS Pro when you need edge compute and container orchestration alongside routing.

RobustOS

Built for the real world (reliability & filesystem)

Remote sites see power loss, limited access, and long service lives. RobustOS Pro is designed so changes are predictable and recovery is fast, with clear paths back to a known-good state.

Resilience Highlights
  • Transactional upgrades and safe rollbacks: Apply builds on a few units, validate, then roll out; if anything misbehaves, revert cleanly without re-imaging and preserve config where appropriate.
  • Layered filesystem for power resilience: Keep the base system protected while writes land in a separate layer so an unexpected power cut still boots a known baseline.
  • Journaling and integrity checks: Use a journaling filesystem and boot-time verification to reduce corruption risk after hard power cycles.
  • Watchdogs and self-healing services: Rely on hardware and service watchdogs with restart policies so critical workloads recover without a site visit.
  • Resource isolation for noisy neighbors: Cap CPU and memory per service or container so one task cannot starve routing, telemetry, or management.
  • Deterministic persistence: Store app state in defined directories, keep temp data in RAM, and rotate logs with limits so behavior stays predictable across reboots and versions.
  • Flash health visibility: Monitor flash wear and I/O trends so you can schedule maintenance before storage becomes a problem.
  • Multiple reset paths: Choose the right recovery level—from restarting a service to reset-to-default or full factory restore—so teams fix issues fast.
  • Diagnostics you can trust: Generate support bundles with system logs, kernel messages, and config snapshots; run packet capture and interface tools locally to prove what happened.

Where the Robustel Edge Gateway experience delivers value 

RobustOS Pro and the Robustel Edge Gateway are designed as one platform. Industrial hardware with router-grade networking, plus a full Debian environment for your applications. The value comes from the two working together: the OS gives you developer freedom and governance; the gateway gives you resilient power, I/O, and links you can trust in the field.

Why Robustel Edge Gateways and RobustOS Pro?
  • Replace an embedded PC: Move your protocol translator and rules engine into containers or a signed native app on the same device that provides routing and security. You keep familiar Linux workflows while gaining industrial power and EMC, hardware and service watchdogs, serial and DI/DO on board, and a deterministic boot and recovery path with remote diagnostics—all delivered by one integrated platform.
  • Brownfield integration: Bridge Modbus RTU/TCP and other serial devices into modern APIs or MQTT without rebuilding your whole stack. The gateway’s ports and I/O give you clean physical access; RobustOS Pro runs the container or native app that maps and validates tags; the router base quietly handles NAT, firewalling, VLANs, and VPN, so your application stays focused on domain logic.
  • Operate through poor connectivity: Keep site logic local on RobustOS Pro and use store-and-forward to protect data when links drop. The gateway manages link health, policy routing, and QoS to make the path predictable, while the OS provides journaling, resource controls, and a layered filesystem so services recover cleanly after power events and come back with known state.
  • All in one edge gateway: Replace a chain of router plus protocol box plus single-board computer with a single Robustel unit running RobustOS Pro. You reduce failure domains, power bricks, and cabling; you get one security surface, one bill of materials, and one lifecycle to patch, audit, and stock spares for—cutting cost and space while improving mean time to repair and root-cause clarity.

Note: RCMS can mirror router operations at scale when required; Debian containers and packages remain managed on the device.

View the Robustel Gateway Portfolio

Work with IoT Experts who Respect your Industry Knowledge

You know your industry best. We bring deep expertise in IoT device development and deployment, turning your goals into stable designs, repeatable profiles, and smooth rollouts. Together we build a long term partnership that supports scale, growth, and efficiency.

Talk to an IoT Expert Today

Additional Information

New to running Debian at the edge or moving workloads from a small PC or Pi onto a gateway? The answers below explain how RobustOS Pro runs containers and native apps on a Robustel edge gateway, what RCMS does (router operations) and does not do (Debian packages and containers), and how we handle security, updates, and recovery in the field. If your question isn’t covered, Talk to an Engineer and we’ll map the best path for your project.

What is RobustOS Pro in one line?

A Debian-based industrial Linux environment running on Robustel edge gateways, so you can deploy containers or native apps on the same device that provides router-grade networking, security, and diagnostics.

How is RobustOS Pro different from RobustOS?

RobustOS is the router operating system for secure connectivity and fleet operations. RobustOS Pro adds a full Linux (Debian) userland for running your applications at the edge—containers or signed native apps—on top of that router foundation.

Do I need RCMS to use RobustOS Pro?

No. You build, install, and operate containers/native apps locally on the device. RCMS can mirror router workflows (config, monitoring, firmware) across fleets later, but it does not manage Debian packages or containers.

Can I run containers? Which tooling works?

Yes—containers are the primary path. Use your standard CI/CD to build and tag images. On the device, set env vars, start order, and restart policy; choose whether the service is governed by RobustOS Pro (UI/CLI control) or treated as a third-party component managed by its own tooling.

When should I use the SDK and a signed .deb instead of a container?

Use the SDK when you need tight integration with device services, minimal overhead, or first-class settings in the Web Manager UI. Signed .deb packages give you a governed, auditable install/upgrade path that “feels native” on the gateway.

Can I port software from a Raspberry Pi or small embedded PC?

Often, yes. RobustOS Pro targets ARMv8 with a standard Debian environment, so many projects port cleanly—gaining industrial power/EMC characteristics, watchdogs, and router-grade networking on the same box.

How are OS and app updates handled?

For the OS, you follow a predictable maintenance path with security updates and the ability to roll forward or back. For your apps, containers pull new images or you install a new signed .deb. Test on a small set, then roll out; if something misbehaves, revert without re-imaging.

What happens if power is lost during an update?

The filesystem is designed to keep the base system bootable and recoverable. Updates are applied predictably; if a change is interrupted or fails validation, you can complete or roll back on the next boot and get back to a known-good state quickly.

How do I make sure a misbehaving app doesn’t take the box down?

Use restart policies and watchdogs for your services, and apply resource controls to keep CPU and memory caps in place. Router functions (VPN, policy routing, link health) stay protected so networking remains predictable.

What about logging and observability?

Use device logs (system/journal), per-service logs, and packet capture/diagnostic bundles for root-cause analysis. Keep persistent app data in defined directories, rotate logs with limits, and use TLS certificates for any upstream publishing.

Can RobustOS Pro handle brownfield protocol work (Modbus, serial)?

Yes—run a container or native app for polling/translation and publish to your chosen broker or API. The gateway provides the serial/I/O and router foundation (NAT, firewall, QoS); your software focuses on clean tag mapping and validation.

How does RobustOS Pro help when links are unreliable or expensive?

Run site logic locally and use store-and-forward to protect data. The router foundation handles link selection, health-checks, and QoS; your app batches and retries with backoff so processes stay stable and data arrives intact.

What security measures are in place?

On the device: role-based access to Web Manager and shells, HTTPS/SSH with your certificates, firewall zones, and signed app installs. On the platform: a structured security update program, independent testing, and transparent release notes so you can plan and audit confidently.

Can I restrict who can access the Linux shell?

Yes. Assign roles, lock down SSH by key/certificate, and use firewall rules to limit management access by network/host. Keep credentials in your process (e.g., privileged break-glass only) and audit with logs.

Does RobustOS Pro support automated security updates?

Automated security updates are supported (with guardrails). Many customers enable them for critical patches while keeping staged rollouts for anything that could affect application behavior.

What’s the best practice for persistent data?

Treat the filesystem deterministically: app data in dedicated directories, temp data in RAM, and log rotation with size limits. That pattern keeps behavior stable across reboots and upgrades and helps you model flash wear over time.

Can I run LoRaWAN packet forwarders or other radio helpers?

On supported models, yes. You can run packet forwarders alongside your applications and router functions on the same device—reducing boxes, power bricks, and cabling.

Which gateways support RobustOS Pro?

RobustOS Pro runs across the Robustel Gateway Portfolio. Check the product page for each model to confirm support, resources, and any feature notes.

How does RobustOS Pro compare to running Linux on a generic mini-PC + a separate router?

You’ll often achieve the same application goals with fewer moving parts: one device, one security surface, one bill of materials, and one recovery path. You keep Linux freedom while gaining hardened power/EMC, industrial I/O, and router-grade networking under the same hood.

Can I orchestrate containers across many gateways?

RobustOS Pro manages services on each device. For fleet-wide orchestration, teams typically extend their CI/CD and configuration management to push versions and policies; RCMS covers router operations, not Debian container orchestration.

Do you have a recommended rollout pattern?

Yes: lab → limited field pilot → staged rollout → broad deployment. Pin versions, sign packages, keep a known-good build, and document a rollback trigger. Plan service windows based on your link policy and flash-health observations.

What support do I get from Robustel?

Two tracks: (1) deployment guidance from engineers who build and run fleets, and (2) documentation and examples for SDK packaging, certificates, and device services. If you prefer, start with a short technical conversation and we’ll co-design a pilot.