HORUS v0.2.0

HORUS 0.2.0 Release Notes

Release Date: March 2026

Highlights

Unified Node API, deterministic replay, cross-process Image pub/sub fix, and a new project manifest system. 179 commits, 662 files changed since v0.1.9.

---

Breaking Changes

Unified Node API - Single Node Trait

The separate RtNode trait is gone. All nodes use Node. RT behavior is auto-detected from builder methods.

// Before (0.1.9)
scheduler.add_dyn(Box::new(my_node));

// After (0.2.0)
scheduler.add(my_node)
    .rate(100_u64.hz())      // RT auto-detected from rate/budget/deadline
    .budget(200_u64.us())
    .on_miss(Miss::Skip)
    .build()?;

Removed methods: .done() (use .build()), .rate_hz() (use .rate(100.hz())), .budget_us() (use .budget(200.us())), .deadline_ms() (use .deadline(1.ms()))

Removed presets: Scheduler::deploy(), ::hard_rt(), ::safety_critical() - use composable builders instead:

Scheduler::new()
    .deterministic(true)
    .tick_rate(100_u64.hz())

DurationExt - Ergonomic Durations

use horus::prelude::*;

100_u64.hz()    // Frequency
200_u64.us()    // Duration (microseconds)
1_u64.ms()      // Duration (milliseconds)

HFrame -> TransformFrame

All types, topics, and CLI commands renamed:

Old	New
HFrame	TransformFrame
HFMessage	TFMessage
topic hf / hf_static	topic tf / tf_static
horus hf	horus frame (alias: horus tf)

horus.toml - Single Source of Truth

horus.toml replaces separate Cargo.toml/pyproject.toml in project roots. Native build files are auto-generated into .horus/.

[package]
name = "my_robot"
version = "0.1.0"
language = "rust"

[dependencies]
horus_core = "0.2.0"
numpy = { version = ">=1.24", source = "pypi" }

[scripts]
run = "cargo run --release"

New CLI commands: horus add, horus remove, horus run <script>, horus migrate (converts old projects)

Topic Names - Dots Not Slashes

Topic names must use dots for cross-platform compatibility (macOS shm_open limitation):

// Before
Topic::new("camera/rgb")

// After
Topic::new("camera.rgb")

---

New Features

Cross-Process Image Pub/Sub (Issue #37 Fix)

Image, PointCloud, and DepthImage now work reliably across separate processes/schedulers. No workarounds needed.

// Process 1
let topic: Topic<Image> = Topic::new("camera.rgb")?;
topic.send(&image);

// Process 2 (separate binary)
let topic: Topic<Image> = Topic::new("camera.rgb")?;
if let Some(img) = topic.recv() {
    // Works - even with 640x480 images, simultaneous startup
}

Deterministic Record/Replay

Bit-identical replay of recorded sessions with a new clock abstraction:

let mut scheduler = Scheduler::new()
    .deterministic(true)
    .tick_rate(100_u64.hz());

// Record
scheduler.record_to("session.horus")?;

// Replay (produces identical outputs)
scheduler.replay_from("session.horus")?;

NodeBuilder - Per-Node Configuration

scheduler.add(my_node)
    .rate(50_u64.hz())
    .budget(500_u64.us())
    .deadline(1_u64.ms())
    .on_miss(Miss::Skip)       // or Warn, SafeMode, Stop
    .priority(90)
    .core(2)                   // Pin to CPU core
    .watchdog(5_u64.secs())
    .order(0)                  // Execution order
    .build()?;

RT Executor Thread Pool

RT nodes now run on dedicated threads with independent scheduling chains. Non-RT nodes run on the main thread.

Fan-Out Topics

One publisher, many subscribers - each gets every message:

let topic: Topic<Imu> = Topic::new("imu.data")?;
// Multiple subscribers automatically get FanoutShm backend

AudioFrame Message Type

New message type for microphone arrays, speech processing, and acoustic anomaly detection.

Ergonomic PointCloud / DepthImage Constructors

let pc = PointCloud::from_xyz(&points)?;
let depth = DepthImage::meters(640, 480)?;

Python Parity

All new builder methods, DurationExt, and time APIs available in Python:

import horus

node = horus.Node("camera", tick=process_frame, rate=30)
scheduler = horus.Scheduler(tick_rate=100, deterministic=True)
scheduler.add(node)
horus.run(node)

---

CLI Changes

New Development Commands

Command	Description
horus add <dep>	Add dependency to horus.toml (--source pypi/crates.io/system/git)
horus remove <dep>	Remove dependency
horus migrate	Convert old Cargo.toml/pyproject.toml project to horus.toml
horus bench [FILTER]	Run benchmarks
horus lint [--fix]	Lint code (clippy + ruff/pylint, --types for mypy)
horus fmt [--check]	Format code (rustfmt + Python formatters)
horus doc [--extract]	Generate docs (--json, --md, --html, --coverage)
horus doctor [--fix]	Diagnose environment, install missing toolchains
horus config	View/edit horus.toml settings
horus deps tree/why/outdated/audit	Dependency insight
horus scripts [name]	Run scripts from [scripts] in horus.toml
horus lock [--check]	Generate/verify horus.lock
horus self update	Update the horus CLI itself

Native Tool Proxies

Use your existing tools transparently inside horus projects - changes sync back to horus.toml:

horus cargo add serde --features derive   # runs cargo, syncs to horus.toml
horus pip install numpy                    # runs pip, syncs to horus.toml
horus cmake --build .                      # runs cmake with horus paths
horus conan install .                      # runs conan with horus sync
horus vcpkg install opencv                 # runs vcpkg with horus sync

Shell integration is set up automatically by the installer. After installing, cargo/pip/cmake auto-detect horus projects:

# Inside any horus project - just use your normal tools:
cargo add tokio     # automatically syncs to horus.toml
pip install scipy   # automatically syncs to horus.toml
cmake --build .     # uses horus paths automatically

Publishing & Registry

Command	Description
horus publish [--dry-run]	Publish package to horus registry
horus unpublish <pkg@ver>	Remove a published version
horus yank <pkg@ver>	Hide from new installs (existing lockfiles still work)
horus deprecate <pkg>	Mark package as deprecated
horus owner add/remove/list	Manage package ownership
horus auth login/logout/status	Registry authentication
horus cache info/clean/purge	Cache management

Multi-Language Support

horus run auto-detects and runs Rust, Python, and C++ files - even mixed in the same command:

horus new my_robot --rust       # Rust project
horus new my_robot --python     # Python project
horus new my_robot --cpp        # C++ project
horus run controller.rs sensor.py  # Mixed-language, concurrent execution

---

Bug Fixes

• Cross-process Image crash (Issue #37) - TensorPool initialization race, migration detection delay, and SHM drain memory ordering all fixed
• Topic slot race condition - fixed data corruption during DirectChannel->SHM migration
• Cross-process IPC latency - removed spin_for_ready from recv hot paths
• Python binding crashes - fixed AudioFrame dispatch, dead API removal
• Service response_topic - missing field caused silent failures
• flock-based SHM cleanup - stale namespaces from crashed processes now detected and removed on startup

---

Migration from 0.1.9

// Node API
scheduler.add(node).order(0).done()        ->  scheduler.add(node).order(0).build()?
scheduler.add(node).rate_hz(100.0)         ->  scheduler.add(node).rate(100_u64.hz())

// Scheduler presets
Scheduler::deploy()                        ->  Scheduler::new().tick_rate(100.hz())
Scheduler::safety_critical()               ->  Scheduler::new().deterministic(true)

// TransformFrame
use horus::prelude::HFrame                 ->  use horus::prelude::TransformFrame
Topic::new("hf")                           ->  Topic::new("tf")

// Topic names
Topic::new("camera/rgb")                   ->  Topic::new("camera.rgb")

// Project manifest
Cargo.toml (in project root)               ->  horus.toml (Cargo.toml generated in .horus/)

---

For questions or issues: https://github.com/softmata/horus/issues

HORUS v0.1.9-alpha

HORUS 0.1.9 Release Notes

Release Date: February 2026

Highlights

This release is a major cleanup and performance release — 77,000 lines of dead code removed, 43 bug/security fixes, and a redesigned Scheduler API with explicit opt-in for RT features.

---

Breaking Changes

1. Scheduler: Lightweight new() + Opt-in RT

Scheduler::new() no longer auto-applies real-time features. It's now zero-cost (no syscalls).

// Before (0.1.8) — auto-applied RT priority, memory lock, CPU pin
let scheduler = Scheduler::new();

// After (0.1.9) — lightweight by default, opt-in to features
let scheduler = Scheduler::new()
    .realtime()        // RT priority + memory lock + CPU pin
    .with_blackbox(16) // 16MB flight recorder
    .tick_hz(1000.0);  // 1kHz tick rate

// Or use a preset:
let scheduler = Scheduler::deploy();           // Production: RT + BlackBox
let scheduler = Scheduler::safety_critical();  // WCET + watchdog + sequential
let scheduler = Scheduler::deterministic();    // Reproducible execution

New presets: deploy(), safety_critical(), high_performance(), hard_realtime(), deterministic()

Removed: prototype(), enable_determinism() (stub), name() (use with_name()), node() (use add_dyn())

2. Topic: 10 Dead APIs Removed

Removed unused network abstraction methods that had zero callers:

from_endpoint(), from_endpoint_with_capacity(), from_config_named(), from_config_file(), with_slot_size(), send_to_network(), recv_from_network(), network_has_messages(), network_backend_type(), migration_stats()

Core send()/recv() API is unchanged.

3. Message Types: Pod Suffix Removed

All message types are now zero-copy POD by default. The Pod suffix has been dropped:

Old	New
DetectionPod	Detection
Detection3DPod	Detection3D
BoundingBox2DPod	BoundingBox2D
BoundingBox3DPod	BoundingBox3D
SegmentationMaskPod	SegmentationMask
PathPlanPod	PathPlan

Duplicate non-Pod types have been deleted.

4. Error Handling

• Removed: HorusError::Other(String) catch-all
• Added: HorusError::Internal { message, file, line } and HorusError::Contextual { message, source }

5. Crate Reorganization

Module	Moved To
ML types	horus_ai (new crate)
IO types	horus-industrial (new crate)
Perception types	Merged into horus_library
ROS2/Zenoh bridge	Extracted to horus-ros2 registry package

---

Performance

Optimization	Impact
Function pointer dispatch for send()/recv()	~15-20% faster hot path
DirectChannel inlined fast path	~3ns same-thread latency
Co-located SHM slot layout	Better cache locality
Batched header updates (every 32 msgs)	Less atomic contention
Parallel scheduler execution mode	Multi-core node execution
Per-node rate limiting	Independent tick rates per node

---

Security & Bug Fixes (43 fixes)

Critical:

• Fix ABA bug in lock-free free list (tensor/CUDA pools)
• Fix alignment UB in PyTensorHandle::from_descriptor
• Fix soundness: Cell<u32> → AtomicU32 in ShmTopic
• Fix race condition in cross-process topic initialization
• Fix multi-producer race conditions in Topic
• Fix SIGSEGV from stale shared memory
• Fix socket fd leak in io_uring backend

Security hardening:

• Path traversal fixes in package install/uninstall and recording handlers
• Integer overflow fixes in 8+ locations
• UTF-8 safety for FixedString and string operations
• Unbounded allocation and fragment reassembly limits
• SAFETY comments added to all 338 unsafe blocks
• Updated vulnerable dependencies (RUSTSEC-2026-0002 and others)

Stability:

• Fix read_latest() returning None on ring buffer wrap
• Fix SPSC→MPSC migration header corruption
• Replace 4 production panics with proper error returns
• Fix heartbeat using hardcoded port instead of peer's actual port
• Fix TCP stream desync and division-by-zero issues

---

New CLI Commands

• horus driver install/remove — Hardware driver management
• horus plugin install/remove — Plugin management
• horus env show/list — Environment info

---

Python Bindings

• All new Scheduler presets and builder methods available in Python
• Node.tick() rate control now handled natively by horus_core
• Dead APIs removed to match Rust cleanup

---

Code Quality

• -77,605 net lines removed across 298 files
• Cranelift JIT system removed (speculative, unused)
• CLI main.rs refactored: 6,442 → 2,084 lines
• Public API surface tightened — internal types no longer exposed
• get_ prefix removed from public API methods

---

Migration Guide

// Scheduler: add .realtime() if you need RT features
Scheduler::new()                    // was auto-RT, now lightweight
Scheduler::new().realtime()         // explicit RT opt-in
Scheduler::deploy()                 // production preset

// Scheduler: use replacements for removed methods
Scheduler::deterministic()          // replaces enable_determinism()
Scheduler::new()                    // replaces prototype()
scheduler.with_name("MyBot")       // replaces name("MyBot")
scheduler.add_dyn(node)            // replaces node(node)

// Topic: use standard constructors
Topic::new("name", None)           // replaces from_endpoint()
Topic::with_capacity("name", 64, None) // replaces from_endpoint_with_capacity()

// Message types: remove Pod suffix
use horus::library::messages::detection::Detection;  // was DetectionPod

// Errors: use specific variants
HorusError::Communication(msg)     // replaces Other(msg)

---

Coming Next

The HORUS registry will begin exposing external packages next week — including simulation environments, hardware drivers, and sensor integrations as installable packages via horus pkg install.

---

For questions or issues: https://github.com/softmata/horus/issues

HORUS v0.1.8-alpha

HORUS 0.1.8 Release Notes

Release Date: January 2026

Performance & Architecture Improvements

This release focuses on maximizing runtime performance, scalability, and debugging capability by separating concerns and removing overhead from the core scheduler.

Breaking Changes

1. Scheduler API: priority → order

The scheduler builder API has been renamed for clarity:

// Before (0.1.7)
scheduler.add(node,0,true);

// After (0.1.8)
scheduler.add(node).order(0).done();

Why: "Order" better reflects execution sequencing, while "priority" implied preemption (which HORUS doesn't support). Lower numbers execute first.

2. Logging Removed from Core Runtime

Context management and logging have been decoupled from the core scheduler:

• Removed: enable_logging parameter from node registration
• Removed: Built-in NodeContext from scheduler
• Result: Zero logging overhead in hot path (~133ns improvement per tick)

Migration:

// Before (0.1.7)
scheduler.add(node, 0, true);

// After (0.1.8)
scheduler.add(node).order(0).done();

// Use send_logged() explicitly when needed or `horus monitor` or `horus topic echo`
topic.send_logged(msg).ok();  // ~300ns (with logging)
topic.send(msg).ok();          // ~167ns (no logging)

3. Context Separation

Node context (for debugging/monitoring) is now opt-in and managed separately:

// Debugging/monitoring is now external to core runtime
// Use `horus monitor` 

Benefits

Performance

• Faster hot path: Removed context overhead from every tick
• Lower memory: No per-node context allocation by default
• Better cache: Tighter scheduler loop

Scalability

• Cleaner separation: Runtime vs. observability
• Flexible debugging: Add telemetry when needed, not always-on
• Production-ready: Deploy without monitoring tax

Developer Experience

• Explicit logging: send_logged() makes overhead visible
• Simpler defaults: New projects start lean
• Better names: .order() is clearer than .priority()

Migration Guide

1. Rename priority() to order() in all scheduler.add() calls
2. Remove enable_logging() parameters (no longer needed)
3. Use send_logged() only where you need monitoring
4. Use send() for high-frequency hot paths

Template Updates

The horus new templates now reflect these changes:

• Non-macro template includes get_publishers() for topic discovery
• Macro paths fixed for proper module resolution
• Default to send_logged() in examples (easy to optimize later)

Full Changelog

• BREAKING: Rename priority() → order() in scheduler API
• BREAKING: Remove enable_logging from scheduler builder
• BREAKING: Remove automatic NodeContext allocation
• FIX: Non-macro template now implements get_publishers()
• FIX: Macro module paths use absolute ::horus::horus_core::
• PERF: Disable safety monitor by default (prototyping-friendly)
• PERF: Zero logging overhead when using send()

---

For questions or issues, visit: https://github.com/softmata/horus/issues

HORUS v0.1.7-alpha

HORUS v0.1.7-alpha

Alpha release with significant architectural changes.

Communication Layer Redesign

The Hub/Link architecture has been unified into a single Topic API. This change aligns HORUS with ROS2 terminology, reducing cognitive overhead for developers transitioning from ROS2 ecosystems.

// Old: Separate Hub and Link with different configurations
let hub = Hub::new("sensor_data")?;
let link = Link::new("sensor_data")?;

// New: Unified Topic API
let topic: Topic<SensorData> = Topic::new("sensor_data")?;
topic.send(data, &mut None)?;
let received = topic.recv(&mut None);

The framework now automatically selects the optimal IPC backend based on message type and access patterns:

Backend	Latency	Use Case
PodShm	~50ns	POD types, cross-process
SpscShm	~85ns	Single producer/consumer
MpmcShm	~167ns	Multiple producers/consumers

Scheduler Improvements

The scheduler now supports Linux real-time scheduling policies:

• SCHED_FIFO for deterministic real-time execution
• SCHED_RR for round-robin real-time scheduling
• Configurable priority levels (1-99)

Requires CAP_SYS_NICE capability or root privileges on Linux.

Codebase Restructuring

This release includes a major refactor to support future scaling:

• sim2d and sim3d: Now developed as standalone packages. They will continue to be maintained separately.
• Built-in nodes: Moved to separate development. These will be open-sourced when feature-complete.
• Core crates: Restructured for modularity (horus_core, horus_manager, horus_ai, horus_perception)

API Changes

Several APIs have changed for improved developer experience. See migration notes in the documentation.

Roadmap

• Current: v0.1.x (Alpha)
• Expected Beta: v0.5.x

---

Full changelog and documentation at: https://github.com/softmata/horus

HORUS v0.1.6-alpha

HORUS v0.1.6 Release Notes

Release Date: December 2025
28 commits since v0.1.5

---

Highlights

This release brings major improvements to simulation capabilities, ultra-low-latency networking, Python bindings, and cross-platform installation. Key highlights include:

• io_uring networking for 3-5µs latency on Linux
• sim3d production-ready with 17 sensor types and RL/ML integration
• Opt-in scheduler learning phase for better determinism control
• Universal installer with embedded/minimal profiles for Raspberry Pi, Jetson, and ARM SBCs

---

New Features

Ultra-Low-Latency Networking with io_uring

Complete io_uring implementation for Linux systems:

• 3-5µs network latency (matching Zenoh-pico performance)
• Zero-copy networking using registered buffers
• SQPOLL mode for kernel-side polling (can saturate 100Gb NIC on single core)
• Requires Linux 5.6+ (5.19+ for SQPOLL without root)
• Enable with io-uring-net feature flag

// Automatic detection - uses io_uring when available
let hub = Hub::new("sensor_data@192.168.1.100:9000")?;

sim3d - Production-Ready 3D Simulator

A complete 3D robotics simulator built with Bevy 0.15 and Rapier3D:

17 Sensor Types:

• RGB-D/Depth cameras with distortion modeling
• IMU (Inertial Measurement Unit)
• GPS/GNSS positioning
• LiDAR 3D scanning
• Event cameras (neuromorphic)
• Force/Torque sensors
• Tactile sensors
• Thermal cameras
• Sonar/Ultrasonic
• Radar
• Encoders
• And more...

RL/ML Integration:

• Curriculum learning system
• Adversarial training support
• Python bindings for RL agents
• Pre-built RL tasks: Balancing, Locomotion, Manipulation, Navigation, Pushing, Reaching
• 60 FPS visual / 100K+ steps/sec headless

Asset Support:

• URDF, MJCF, SDF import
• Gazebo model loading
• YCB object dataset integration
• FBX, OBJ, STL, COLLADA, USDZ formats

Physics:

• Soft body simulation (cloth, ropes, particles)
• Advanced constraint handling
• Rapier3D integration

sim2d Improvements

• Joint command support for manipulating kinematic chains
• Python API for 2D simulation scenarios
• Kinematics and inverse kinematics solvers
• Recording and playback functionality
• Metrics collection during simulation

Scheduler - Opt-in Learning Phase

The adaptive learning phase is now opt-in instead of always-on:

let config = SchedulerConfig {
    learning_phase: false,  // Disable for deterministic behavior
    ..Default::default()
};
let scheduler = Scheduler::with_config(config);

This provides better control for:

• Systems requiring deterministic timing
• Production deployments where profiling overhead isn't needed
• Hard real-time applications

Python Bindings - Network Support

Full network communication support in Python:

import horus

# Network-aware Hub (auto-detects local vs remote)
hub = horus.Hub("sensor_data@192.168.1.100:9000")

# Check if using network transport
if hub.is_network():
    print(f"Connected to remote endpoint")

# RouterClient for multi-robot communication
client = horus.RouterClient("robot_fleet@router.local:8080")

New Built-in Nodes

HORUS now includes 37+ production-ready nodes:

New in v0.1.6:

• KeyboardInputNode - Terminal keyboard capture (crossterm-based)
• JoystickInputNode - Gamepad/joystick support (gilrs-based)
  • Button mapping profiles (Xbox360, PlayStation4, Generic)
  • Axis calibration support

Categories:

Category	Count	Examples
Sensors	12	Camera, Depth Camera, LiDAR, IMU, GPS, Encoder
Actuators	8	DC Motor, BLDC, Stepper, Servo, Dynamixel
Safety	3	Battery Monitor, Safety Monitor, Emergency Stop
Communication	6	CAN Bus, Modbus, Serial, I2C, SPI
Navigation	4	Odometry, Localization, Path Planner, Collision
Control	2	PID Controller, Differential Drive
Input	2	Keyboard, Joystick

---

Improvements

Universal Installation Script

The installer now supports platform profiles for different deployment targets:

Profile	Packages	Best For
Full	All (sim2d, sim3d included)	Desktop, Workstation, Development
Embedded	Core + library, no heavy GUI	Raspberry Pi, Jetson, ARM SBCs
Minimal	Essential runtime only	Resource-constrained devices, CI/CD

Auto-detection for:

• Raspberry Pi (all models)
• NVIDIA Jetson
• BeagleBone
• Generic ARM SBCs

New Features:

• Smart progress bars with ETA calculation
• Automatic dependency detection and installation
• GitHub issue creation on build failure (with permission)
• Better error recovery for locked files
• Version-specific library caching

Dashboard/TUI Updates

• Replaced tui-nodes graph view with canvas-based visualization
• Improved responsiveness and visual feedback
• Network communication detection in monitor command
• Added horus profile command for system profiling

Documentation

• Enhanced search functionality in docs-site
• Fixed panel docking in sim3d editor
• Updated built-in nodes documentation

---

Breaking Changes

horus_mcp Extracted

The horus_mcp development tooling has been moved to a separate repository. If you were using the MCP server for development, install it separately:

# horus_mcp is now a separate tool
# See: https://github.com/softmata/horus-mcp

Topic Naming

Topic names now use . instead of / as separators internally. This is handled automatically but may affect debugging output:

# Old: /sensor/lidar/scan
# New: sensor.lidar.scan

---

Performance

Metric	v0.1.5	v0.1.6
Hub round-trip	~481ns	~481ns
Link round-trip	~248ns	~248ns
Network (io_uring)	N/A	3-5µs
sim3d headless	N/A	100K+ steps/sec

---

Bug Fixes

• Fixed docking panel behavior in sim3d editor
• Fixed verify.sh script issues
• Fixed degree viewpoint calculation when spawning MAP in sim3d
• Fixed discovery context handling
• Improved error handling in install script for locked files

---

Upgrading

# Clean install recommended
rm -rf ~/.horus/cache
cd /path/to/HORUS
./install.sh

Select your platform profile:

1. Full - Desktop/workstation development
2. Embedded - Raspberry Pi, Jetson, ARM SBCs
3. Minimal - CI/CD, resource-constrained devices

---

Dependencies Updated

• Bevy: 0.15 (graphics/simulation)
• Rapier3D: 0.22 (physics)
• PyO3: 0.27 (Python bindings)
• io-uring: 0.6 (Linux networking)

---

What's Next (v0.1.7 Preview)

• WebAssembly support for browser-based simulation
• ROS2 bridge improvements
• Additional RL environments
• GPU-accelerated perception nodes

---

Links

• Documentation
• Installation Guide
• Discord Community
• GitHub Issues

---

Full Changelog: v0.1.5...v0.1.6

Version 0.1.5

HORUS v0.1.5

Release Notes

This release brings version consistency across the entire HORUS ecosystem, updates to the core framework, and improvements to external tooling.

What's Changed

Version Synchronization

• All core packages updated to v0.1.5
• Python bindings synchronized to v0.1.5
• C++ API updated to v0.1.5
• Documentation site updated to v0.1.5
• External tools (marketplace, discord bot) updated to v0.1.5

Core Packages

• horus - Main CLI tool
• horus_core - Core IPC and messaging library
• horus_library - Standard robotics nodes and messages
• horus_py - Python bindings
• horus_cpp - C++ API bindings
• horus_manager - Package manager
• horus_router - Message routing
• horus_macros - Procedural macros

Python Packages

• horus - Python bindings (PyPI)
• horus.library - Standard robotics messages
• sim3d_rl - 3D simulation RL environments

Documentation

• Updated all version badges to v0.1.5
• Updated installation path examples
• Updated CLI version references
• Synchronized API documentation versions

External Ecosystem

• horus-marketplace: Registry and package repository updated to v0.1.5
• horus-discord-bot: Community bot updated to display v0.1.5-alpha

Installation

From Source

git clone https://github.com/your-org/HORUS
cd HORUS
./install.sh

Verify Installation

horus --version  # Should show 0.1.5

Compatibility

Binary Compatibility

All message types remain binary-compatible with previous 0.1.x releases. Shared memory IPC between different language bindings (Rust, Python, C++) continues to work seamlessly.

API Compatibility

This release maintains API compatibility with v0.1.4. No breaking changes have been introduced.

Upgrade Guide

If upgrading from v0.1.4 or earlier:

1. Pull the latest changes:

   git pull origin main

2. Run the installation script:

   ./install.sh

3. Verify the upgrade:

   horus --version

4. Update your project dependencies in horus.yaml:

   dependencies:
     horus_core: "^0.1.5"
     horus_library: "^0.1.5"

Package Locations

After installation, packages are located in:

• Rust: ~/.horus/cache/horus_core-0.1.5/
• Python: ~/.horus/cache/horus_py-0.1.5/
• C++: ~/.horus/cache/horus_cpp-0.1.5/
• Library: ~/.horus/cache/horus_library-0.1.5/

Known Issues

None reported for this release.

Contributors

Thank you to all contributors who made this release possible.

Links

• Documentation: https://code.claude.com/docs
• Marketplace: https://horus-marketplace-api.onrender.com
• Discord: Join our community
• Issues: Report bugs on GitHub

---

Full Changelog: https://github.com/your-org/HORUS/compare/v0.1.4...v0.1.5

Version 0.1.4

HORUS v0.1.4 - Documentation & UX Improvements

1. Documentation Enhancements

New Documentation

• Python Message Library Reference - Complete 350-line guide covering all 9 message types (Pose2D, Twist,
  Transform, Point3, Vector3, Quaternion, CmdVel, LaserScan) with full API documentation and cross-language
  compatibility tables
• Enhanced Python Bindings Guide - Improved accuracy with corrected cross-language examples and dashboard
  integration limitations

Documentation Fixes

• Multi-Language Support - Fixed typed hub imports, corrected build process documentation (cargo build vs
  rustc), added comprehensive mixed-language system examples
• Cross-Language Communication - Clarified when to use typed hubs (PyPose2DHub, PyCmdVelHub,
  PyLaserScanHub) vs generic Hub for Python-Rust interop

2. Documentation Site Improvements

Visual Enhancements

• Theme-Aware Syntax Highlighting - Fixed light/dark mode code block rendering with proper theme detection
  using MutationObserver
• High-Contrast Code Blocks - Added accessible color schemes for both light and dark modes meeting WCAG AA
  standards
• Copy to Clipboard - Added copy button to all code blocks with visual feedback and smooth transitions

Technical Details

• Updated PrismJS integration with dynamic theme switching
• Custom CSS overrides for optimal readability in both modes
• Improved code block styling with proper font rendering for ASCII diagrams

3. Bug Fixes

• horus_manager - Fixed Sim2D command parameter handling (world_image, resolution, threshold)
• horus_manager - Corrected borrowing issues in command argument passing
• horus_manager - Fixed Option type handling for resolution and threshold parameters

4. Build Information

• Rust Workspace: All crates compile successfully
• Documentation Site: 52 pages generated successfully
• Binary Size: 281MB (debug), 90MB (daemon)
• Build Time: ~1m 41s

5. Known Issues

Minor cosmetic warnings present (unused variables in benchmarks/tests) - these don't affect functionality
and will be addressed in future releases.