0.4.0

Iris 0.4.0 – “Hybrid‑Runtime” 🎯

This release turns a proof‑of‑concept actor library into a full
hybrid runtime with a built‑in Cranelift JIT. Python users can now
offload math expressions to native code, and the core actor system
remains lightweight and dependable.

🚀 Highlights

• JIT first‑class

  • Full expression language with arithmetic, power, modulo, comparisons,
    booleans (and, or, not), ternary, chained comparisons and
    unary minus.
  • Loop support: range() generators, step/predicate filtering,
    constant‑unrolled loops, vectorized sum‑over semantics.
  • Heuristic optimizer that folds constants, simplifies algebra,
    handles math calls and casts, and safely rewrites loops.
  • Python decorator (@iris.offload(strategy='jit')) with fallback to
    original Python and a call_jit/offload_call API.
  • Configurable logging (IRIS_JIT_LOG env var + runtime API).

• Python integration improvements

  • Parser, codegen and heuristics now accept True/False literals.
  • JIT logging can be toggled from Python.
  • Offload decorator extracts return expression automatically.
  • Improved tests covering mixed expressions, generator loops, and
    logging API.

• Documentation & packaging

  • README reorganized to reflect hybrid runtime story and JIT
    capabilities.
  • Node.js maturity warning added.

• CI robustness

  • Fixed failing PyO3 tests by removing unreliable import iris
    calls; module is injected directly into sys.modules.
  • Added corresponding Python scoping fix.

• Miscellaneous

  • Numerous unit and integration tests added or strengthened.
  • Logging now goes through a centralized hook.
  • Code refactorings and cleanups (unused imports/warnings).

🛠 Upgrade notes

• The public Rust API (Runtime, Pid, message envelopes) is
  unchanged; only new JIT/pybind features have been added.
• Python helper iris/jit.py gained set_jit_logging/get_jit_logging.

Enjoy the speedups and let us know what you build!

Full Changelog: v0.3.0...0.4.0

v0.3.0

Iris v0.3 – The Resilience Release 🌸

This release marks a massive leap for the project, officially transitioning from Myrmidon to Iris. This version evolves the core from a high-performance experiment into a resilient, self-healing, and language-agnostic foundation designed for the modern era.

---

🚀 Performance: Shifting into High Gear

The "Final Boss" stress tests on legacy single-core hardware (Celeron 900) and modern ARM (Unisoc T606) have set a new performance ceiling:

• Record-Breaking Throughput: Achieved ~563,258 msgs/sec for threaded pull actors and ~409,927 msgs/sec for push actors.
• Mechanical Sympathy: Validated that single-core execution eliminates cross-core atomic lock contention, maximizing L2 cache warmth and instruction efficiency.
• High-Speed Hot-Swapping: Logic upgrades now execute at an astounding 85,119 swaps/sec while simultaneously processing over 340k msgs/sec.

🛡️ Resilience & Self-Healing

We’ve moved beyond "Let it Crash" to a fully active distributed mesh:

• Path-Based Supervision: Actors are now structured in hierarchical paths (e.g., /svc/chaos/handler), managed by supervisors that utilize automatic restart factories.
• Remote Monitor Heartbeats: Introduced monitor_remote functionality that performs health probes on remote nodes, triggering local fail-safes to prevent split-brain scenarios.
• Dynamic Location Transparency: "Smart Clients" can now automatically re-resolve service paths, allowing them to follow actors across PID migrations during restart events without dropping TCP connections.

🔄 Core Refinements

• The Iris Identity: Global namespace migration to Iris to reflect the project's growth into a sophisticated, multi-language engine.
• Scheduler Starvation Prevention: Refined the Cooperative Reduction Scheduler to ensure strict fairness by yielding to the Tokio runtime via a reduction budget.
• Atomic Hot-Swapping: Upgrades now preserve the actor's existing mailbox queue, ensuring zero data loss during logic transitions.

---

📦 Installation (Alpha)

# Clone the repository
git clone https://github.com/seuriin/iris.git
cd iris

# Build the Rust core and Python bindings
maturin develop

🏁 Quick Start: Supervised Self-Healing

import iris
import time

rt = iris.Runtime()
rt.listen("127.0.0.1:9000")

def handler(msg):
    print(f"🟢 Processing: {msg.decode()}")

# 1. Setup a path-scoped supervisor
rt.create_path_supervisor("/system/worker")

# 2. Attach a restart factory
def factory():
    pid = rt.spawn(handler, release_gil=True)
    rt.register_path("/system/worker/active", pid)
    return pid

initial_pid = factory()
rt.path_supervise_with_factory("/system/worker", initial_pid, factory, "restartone")

# Iris now monitors and restarts your actor automatically.

---

Note

Production Status: Iris is currently in Alpha. The binary protocol is subject to change. Always use the Supervisor for critical actor lifecycles to ensure automatic recovery.

Full Changelog: https://github.com/SSL-ACTX/Iris/commits/v0.3