domain-embedded

Enforce no_std constraints and safe hardware ownership in Rust microcontroller code.

Updated Feb 8, 2026
One-click install
npx skills add https://github.com/yumazak/kodo --skill domain-embedded-yumazak
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: domain-embedded
Source: https://github.com/yumazak/kodo/tree/main/.agents/skills/domain-embedded
Command: npx skills add https://github.com/yumazak/kodo --skill domain-embedded-yumazak

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The Embedded Domain skill guides developers to design and implement no_std Rust applications for resource-constrained hardware, enforcing domain constraints and safe ownership practices to prevent heap use and timing issues.

Core Features & Use Cases

  • Enforces no-heap design for deterministic memory.
  • Provides patterns for interrupt-safe, static state management.
  • Helps map hardware ownership and lifecycle with HAL and PACs in embedded Rust.

Quick Start

Begin with a minimal no_std MCU project and apply static ownership and heapless patterns to avoid dynamic allocation.

Frequently Asked Questions about domain-embedded

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

FAQPage Schema
How do I design no_std Rust firmware for bare-metal microcontrollers?

To design no_std Rust firmware for bare-metal microcontrollers, you must enforce no-heap constraints, utilize heapless data structures, and apply safe hardware ownership patterns via HAL crates to ensure deterministic memory behavior.

What is the best way to manage static state safely in interrupt-driven embedded Rust?

Managing static state safely in interrupt-driven embedded Rust requires applying Mutex patterns for interrupt safety, ensuring clear ownership of peripherals, and avoiding dynamic memory allocation to prevent timing issues.

Can I use dynamic memory allocation with embedded-hal and PACs in bare-metal Rust?

You cannot use dynamic memory allocation with embedded-hal and PACs in bare-metal Rust if you need deterministic behavior. The design enforces no_std constraints and heapless data structures to avoid heap use and timing issues.

How do I establish safe hardware ownership and peripheral lifecycle mapping in embedded Rust?

To establish safe hardware ownership in embedded Rust, you map the hardware peripheral lifecycle using HAL crates and PACs, enforcing static ownership patterns to guarantee deterministic access and prevent resource conflicts.

Why does my no_std embedded Rust project face timing issues and heap constraints?

Your no_std embedded Rust project faces timing issues and heap constraints if dynamic memory is used instead of heapless data structures. Applying static ownership and Mutex patterns for interrupt safety eliminates these timing problems.