ReluLayer™

Deterministic Edge Governor & Real-Time Execution Gatekeeper for Physical Super Intelligence (SI), Autonomous Robotics, and High-Assurance Actuators.

Quickstart

Pre-Compiled Universal Wheels (Recommended)

ReluLayer™ publishes pre-compiled binary wheels for Linux (x86_64, aarch64) and macOS (arm64, x86_64). No local Rust toolchain or C-compiler is required:

pip install --upgrade relulayer

Verify in Python:

import relulayer
from relulayer import ReluBoundary

# Instantiate deterministic edge governor with stack-allocated bounds
boundary = ReluBoundary(
    max_velocity_rad_s=4.18,
    monotonic_window_size=64,
    hmac_key=b"0123456789abcdef0123456789abcdef"
)

# Fast-path verification (0.199 µs)
receipt = boundary.authorize_action(
    target_axis=0,
    requested_position=1.57,
    commanded_velocity=2.0
)
assert receipt.is_authorized

Source Build Fallback (Embedded & Custom Targets)

For bare-metal microcontrollers (ARM Cortex-R52/M7, RISC-V), QNX, or VxWorks:

1. Install Prerequisites:

   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
   pip install maturin
   

2. Build #![no_std] Separation Kernel:

   cargo build --release --no-default-features
   

3. Install Local Development Bindings:

   maturin develop --release
   

Latency

Short tool calls take the sub-512-byte fast path. Larger payloads stream through 4 Kibibyte (KiB) stack windows up to a 64 KiB policy ceiling. The kernel does not allocate.

Host builds enable the std feature so tests and PyO3 can link the standard library. Production firmware builds disable std and compile as #![no_std] with 0 bytes of heap in the kernel.

When to Use ReluLayer (Applicability Matrix)

ReluLayer is not a conversational text filter. It is an execution-level gatekeeper that proves an action was authorized and prevents it from being tampered with or replayed in the moment it crosses from planner to host.

• Semantic Content Filters (Guardrails AI, NVIDIA NeMo): Run secondary LLM calls or regex parsing to evaluate conversational text ($18\text{--}25,\text{ms}$, dynamic heap memory). Use them for brand tone, PII redaction, and chatbot toxicity.
• Execution-Level Gatekeepers (ReluLayer): Intercept raw execution payloads (APIs, SQL, motor actuators) directly before execution ($0.199,\mu\text{s}$, zero dynamic heap, anti-replay monotonicity). Use ReluLayer for tool calling, robotics control loops, and mission-critical actions.

Examples & Cookbook

For copy-pasteable, runnable recipes covering TOCTOU-safe database tool calling, distributed replay prevention, and high-frequency robotics motor governance, see COOKBOOK.md.

Formal verification

relulayer-proofs contains AWS Kani harnesses that prove streaming HMAC equivalence and replay monotonicity by mathematical induction over the hasher state. The harnesses compile only under cfg(kani).

Build

cargo test --workspace

PyO3 needs a local CPython. If the dynamic linker cannot find libpython, prefix the test command with the interpreter's library directory:

LD_LIBRARY_PATH="$(python3 -c 'import sysconfig; print(sysconfig.get_config_var("LIBDIR"))'):$LD_LIBRARY_PATH" cargo test --workspace

Enterprise & High-Assurance Evaluation

ReluLayer™ is engineered specifically for physical autonomy domains where probabilistic software failure risks kinetic destruction, actuator runaway, or loss of life. While probabilistic foundation models and Vision-Language-Action (VLA) networks handle high-level planning, ReluLayer™ operates as the deterministic, hardware-adjacent Edge Governor and Execution Gatekeeper.

Regulatory Safety Standards Alignment

Inbound Engagement Protocol: Enterprise Design Partners

We partner with autonomous vehicle OEMs, defense contractors, robotics integrators, and critical infrastructure operators requiring verified, tamper-evident execution control.

Design partners receive dedicated engineering co-development for mission-critical deployments:

[Inbound Intake]
       │
       ▼
[Architecture & Threat Model Review] ────► 1-Week Analysis of Actuator & Compute Bus
       │
       ▼
[Custom Hardware Integration Harness] ───► Board Support Package (BSP) for QNX, VxWorks, or FPGA
       │
       ▼
[Dedicated Hardware-in-the-Loop Testbed] ► Latency, Jitter, & Fault-Injection Verification
       │
       ▼
[Co-Developed Production Deployment] ───► ReluLayer™ Safety Edition License & Qualification Data

1. Architecture & Threat Model Review: Complete audit of your motion planner-to-actuator control loop. We identify TOCTOU race conditions, non-deterministic latency spikes, and unauthorized actuator command injection surfaces.
2. Custom Hardware Integration Harness: Tailored integration for mission-critical target environments, including bare-metal microcontrollers (ARM Cortex-R52/M7, RISC-V RV64GC), real-time operating systems (QNX Neutrino 7.1+, VxWorks 653), and low-latency PCIe/CAN-FD interfaces.
3. Dedicated Hardware-in-the-Loop (HIL) Testbed: Rigorous edge injection testing under saturation workloads. We prove absolute boundary enforcement down to $0.199,\mu\text{s}$ authorization latency under hardware failure conditions.

To initiate an architectural evaluation under Mutual NDA, contact: Defense & Aerospace Solutions Group: ishmael.amin@outlook.com Direct inquiries referencing Air Force SBIR D2P2 Topic DAF26BX06-DV026 receive prioritized technical evaluation within 24 hours.

Safety & Compliance Roadmap (2026–2027)

ReluLayer™ follows an open-core, high-assurance roadmap designed to support civil certification and military airworthiness qualifications:

       Q4 2026                        Q1 2027                        Q2 2027                        Q3 2027
┌──────────────────────┐      ┌──────────────────────┐      ┌──────────────────────┐      ┌──────────────────────┐
│  Phase II SBIR D2P2  │      │  Kani & Creusot SV   │      │  IEC 61508 Pre-Cert  │      │ DO-178C DAL A Pack   │
│  Flight Verification │ ────►│  Mathematical Proofs │ ────►│  Functional Safety   │ ────►│ Avionics Tool Qual   │
│  Actuator Isolation  │      │  Zero-Panic Baseline │      │  SIL 3/4 Artifacts   │      │ PSAC / TOR Bundles   │
└──────────────────────┘      └──────────────────────┘      └──────────────────────┘      └──────────────────────┘

• Q4 2026 (Air Force SBIR D2P2 Alignment — Topic DAF26BX06-DV026):
  • Demonstration of flight-critical actuator command isolation under contested electromagnetic interference and adversarial compute interception.
  • Delivery of zero-heap monotonic sequencing kernel running bare-metal on military-grade avionics compute blocks.
• Q1 2027 (Formal Static Verification Proofs):
  • Integration of model checking and formal verification toolchains (Kani Rust Verifier, Creusot).
  • Mathematical verification of zero-panic invariant states, absence of arithmetic overflow, and bounded stack consumption ($< 4,\text{KB}$).
• Q2 2027 (IEC 61508 SIL 3/4 Functional Safety Package):
  • Third-party assessment of failure modes, effects, and diagnostic analysis (FMEDA).
  • Production of deterministic hazard mitigation matrices for industrial robotics workcells.
• Q3 2027 (DO-178C Tool Qualification Data Packs):
  • Release of ReluLayer™ Safety Edition documentation: Plan for Software Aspects of Certification (PSAC), Software Tool Qualification Plan (STQP), and Tool Operational Requirements (TOR).

License

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE)
• Massachusetts Institute of Technology (MIT) license (LICENSE-MIT)

at your option.