Platform Support

HORUS runs on Linux, macOS, and Windows. The core framework — topics, nodes, scheduler, shared memory IPC — works identically on all platforms. You write the same code everywhere. The horus_sys hardware abstraction layer handles OS differences internally.

Quick Summary

Same Code, Every Platform

Your HORUS application code is platform-independent. This Rust node runs on all three OSes:

// simplified
use horus::prelude::*;

struct SensorNode {
imu_sub: Topic<Imu>,
}

impl SensorNode {
fn new() -> HorusResult<Self> {
    Ok(Self { imu_sub: Topic::new("imu.data")? })
}
}

impl Node for SensorNode {
fn name(&self) -> &str { "sensor" }
fn tick(&mut self) {
    if let Some(reading) = self.imu_sub.recv() {
        println!("accel: {:?}", reading.linear_acceleration);
    }
}
}

fn main() -> HorusResult<()> {
let mut scheduler = Scheduler::new()
    .tick_rate(100_u64.hz());

scheduler.add(SensorNode::new()?)
    .order(0)
    .rate(100_u64.hz())
    .build()?;

scheduler.run()
}

No #ifdef, no platform checks, no conditional imports. HORUS handles it.

How It Works Under the Hood

Shared Memory (IPC)

HORUS uses shared memory for zero-copy inter-process communication. Each platform uses a different OS mechanism, but the API is identical:

You never interact with these directly. When you call Topic::new("sensor.imu"), HORUS creates the shared memory region using the right backend for your OS.

Real-Time Scheduling

Real-time scheduling quality varies by OS:

When you call .rate(100_u64.hz()) or .budget(200_u64.us()) on a node builder, HORUS automatically uses the best available RT mechanism. On macOS and Windows, real-time guarantees are weaker — the framework does its best, but the OS kernel doesn't provide the same determinism as Linux with PREEMPT_RT.

Timer Precision

Your code doesn't need to handle this — Scheduler uses the best available timer automatically.

CLI Commands

All horus CLI commands work on every platform:

horus new my-project      # Create a project
horus build               # Build it
horus run                 # Run it
horus test                # Test it
horus check               # Lint and validate
horus doctor              # Check system health

Scripts

Scripts defined in horus.toml run through the platform's native shell:

[scripts]
build-release = "cargo build --release"    # Works everywhere
start-sim = "horus sim3d --headless"       # Works everywhere

File Paths

HORUS handles path separators automatically. Use forward slashes in horus.toml — they work on all platforms:

[dependencies]
my-driver = { path = "drivers/my-driver" }   # Works on Windows too

Platform-Specific Notes

Linux

Linux is the primary development and deployment platform for HORUS.

• Full real-time support with PREEMPT_RT kernel (see RT Setup Guide)
• Plugin sandboxing via seccomp-BPF for untrusted plugins
• Device access via /dev/* (serial ports, cameras, GPIO)
• Deploy to robots with horus deploy (requires SSH + rsync on target)

macOS

macOS is fully supported for development and testing.

• Shared memory uses shm_open() kernel objects — no /dev/shm directory needed
• No PREEMPT_RT — real-time scheduling uses Mach thread constraints (best-effort)
• No plugin sandbox — seccomp is Linux-only. Plugins run without sandboxing
• Xcode Command Line Tools are the only prerequisite (xcode-select --install)

Windows

Windows support is for development and testing. Production deployment should target Linux.

• Shared memory uses Windows file mappings (pagefile-backed) — works without special setup
• Real-time scheduling uses REALTIME_PRIORITY_CLASS — weaker guarantees than Linux
• No plugin sandbox — seccomp is Linux-only
• No rsync/ssh by default — horus deploy requires WSL 2 or Git Bash

Developing Cross-Platform Projects

If your HORUS project needs to work on multiple OSes:

1. Use dots in topic names — "sensor.imu" not "sensor/imu"
2. Avoid Unix-specific tools in scripts — or provide platform alternatives
3. Test RT-sensitive code on Linux — macOS/Windows RT jitter is higher
4. Use horus doctor to check platform capabilities on any machine
5. Deploy to Linux for production — develop anywhere

Compile-Time Verification

HORUS verifies cross-platform compilation in CI on every commit:

• Linux x86_64: Full build + 3,000+ tests
• macOS x86_64 + ARM64: Full build + tests
• Windows x86_64: Full build + core tests
• Linux ARM64: Cross-compilation check (for Raspberry Pi / Jetson)

If your code compiles on any one platform, it compiles on all of them.