rust-core-arch

Define Rust core architecture with polyglot bindings and testing standards.

836|66|Updated Feb 3, 2025
One-click install
npx skills add https://github.com/kreuzberg-dev/html-to-markdown --skill rust-core-arch
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-core-arch
Source: https://github.com/kreuzberg-dev/html-to-markdown/tree/main/.codex/skills/rust-core-arch
Command: npx skills add https://github.com/kreuzberg-dev/html-to-markdown --skill rust-core-arch

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a comprehensive guide to the Rust core architecture, emphasizing modularity, performance, and robust error handling, along with conventions for polyglot integration.

Core Features & Use Cases

  • Core Library Design: Details on Rust crate structure, domain logic separation, and performance optimizations.
  • Integration Points: Outlines how the Rust core integrates with various languages (Python, Node.js, Ruby, PHP, WASM, C/Java/C#) via bindings.
  • Testing & Quality: Specifies rigorous testing strategies, Rust edition standards, and strict quality gates (clippy, coverage, no unwraps).
  • Polyglot Conventions: Defines naming, error handling, async, memory management, and plugin patterns for cross-language compatibility.
  • Module Organization: Best practices for structuring Rust modules and designing public APIs.

Quick Start

Review the Rust core architecture and polyglot conventions for building robust cross-language software.

Frequently Asked Questions about rust-core-arch

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

FAQPage Schema
How do I structure a Rust core library for polyglot integration?

Structure a Rust core library for polyglot integration by separating domain logic into modular crates, enforcing strict error handling, and defining FFI integration points for Python, Node.js, Ruby, PHP, and WASM.

What are the best practices for Rust module organization and public API design?

Rust module organization and public API design best practices emphasize modularity, domain logic separation, and cross-language compatibility conventions to ensure robust, maintainable architecture.

How do I expose Rust functions to Python, Node.js, and Ruby via FFI?

Expose Rust functions to Python, Node.js, and Ruby by defining specific FFI integration points and bindings, following polyglot conventions for naming, async operations, and memory management.

What testing strategies and quality gates should I apply to a Rust core architecture?

Apply rigorous testing strategies to Rust core architecture by enforcing strict quality gates including clippy, coverage thresholds, and a strict no-unwrap policy to ensure robustness.

Can I use a single Rust core library with both WASM and PHP bindings?

Yes, you can use a single Rust core library with both WASM and PHP bindings by defining specific integration points and following polyglot conventions for cross-language compatibility.

How does polyglot error handling work when integrating Rust with other languages?

Polyglot error handling in Rust integrations requires defining specific conventions for error propagation across language boundaries, ensuring robust cross-language compatibility without relying on panics.