rust-systems

Build Rust edge systems with Tokio, Modbus, MQTT, and Axum.

Updated Feb 2, 2026
One-click install
npx skills add https://github.com/JNZader-Vault/project-starter-framework --skill rust-systems-jnzader-vault
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-systems
Source: https://github.com/JNZader-Vault/project-starter-framework/tree/main/.ai-config/skills/systems-iot/rust-systems
Command: npx skills add https://github.com/JNZader-Vault/project-starter-framework --skill rust-systems-jnzader-vault

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides patterns and tools for building robust, high-performance Rust systems, particularly for edge computing scenarios involving Modbus, MQTT, and asynchronous operations.

Core Features & Use Cases

  • Asynchronous Runtime: Leverages Tokio for efficient, concurrent execution.
  • Industrial Protocols: Integrates Modbus for device communication and MQTT for IoT messaging.
  • Configuration Management: Handles application settings through a flexible configuration system.
  • API Development: Includes an Axum-based API for service interaction.
  • Use Case: Develop a Rust-based edge device that reads sensor data via Modbus, publishes it to an MQTT broker, and exposes a health check API.

Quick Start

Configure and run a Rust system service using the provided patterns and dependencies.

Frequently Asked Questions about rust-systems

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I build a Rust edge device that reads Modbus sensors and publishes to MQTT?

Build a Rust edge device by using Tokio for async execution, tokio-modbus for sensor communication, and rumqttc for MQTT messaging. This pattern enables concurrent data polling and publishing for industrial IoT workloads.

What is the best way to structure an async Rust application for industrial IoT communication?

Structure an async Rust application using a Tokio runtime with Serde for data serialization and thiserror for error handling. This combination ensures maintainable, concurrent execution for industrial IoT communication protocols.

Does this Rust systems pattern support exposing an HTTP API alongside MQTT and Modbus?

Yes, the Rust systems pattern supports exposing an HTTP API using Axum. This allows the edge service to handle industrial Modbus and MQTT data while simultaneously providing a health check or service interaction endpoint.

How does Tokio handle concurrent Modbus polling and MQTT publishing in Rust edge computing?

Tokio handles concurrent Modbus polling and MQTT publishing by providing an asynchronous runtime that executes multiple I/O tasks without blocking. This allows Rust edge computing systems to simultaneously read sensors and publish messages.

When should I use thiserror for error handling in a Rust async edge computing system?

Use thiserror in a Rust async edge computing system when you need structured, custom error types across application layers. It integrates with Tokio and Serde to ensure consistent error propagation during Modbus and MQTT operations.