Rul (.rl) v0.2.0 — Standalone Toolchain CLI (rul), Official 1-Bit Binary Identity & Prebuilt Linux x86_64 Binaries

Rul (.rl) v0.2.0 Release Highlights

1. Official Standalone rul Toolchain CLI (Zero-Cargo Project Workflow)

New users and Autonomous AI Agents can now install rul in a single command (without needing Rust or cargo installed on Linux x86_64) and scaffold pure .rl / .rls projects anywhere:

curl -fsSL https://raw.githubusercontent.com/rul-lang/rul/main/install.sh | sh
rul new my-ai-pipeline
cd my-ai-pipeline
rul check
rul build
rul run
rul autotune

2. Prebuilt Zero-Dependency Linux x86_64 Binaries Attached

• rul-linux-x86_64.tar.gz (contains rul, rul-mcp, and rul-bench)
• rul-linux-x86_64.tar.gz.sha256

3. Official 1-Bit Monochrome Binary Block Brand Identity

• Added assets/logo/ suite (rul-mark.svg, rul-mark-inverted.svg, rul-banner-dark.svg, rul-banner-light.svg, rul-favicon.svg).

Rul (.rl) v0.1.0 — 128-Bit Binary Programming Language & Execution Engine for AI Agents

Rul (.rl) v0.1.0 — The AI-Native 128-Bit Binary Programming Language & Execution Engine

Original Creator & Lead Architect: Tran Trong Tri (Tymon Tran) <tymon3568@gmail.com>
License: Dual-licensed under MIT OR Apache-2.0 (with NOTICE & TRADEMARK.md)

Rul (.rl — Rule-Carrying Unified Linear Graph) is a new programming language and execution engine designed from first principles exclusively for Autonomous AI Agents.

Instead of forcing AI Agents to emit verbose ASCII source text and wait seconds or minutes for lexical parsing, borrow-checking constraint solvers, and 100+ heuristic LLVM passes, Rul represents programs as memory-mapped, zero-copy topological SSA-DAGs where every instruction is a fixed 128-bit (16-byte) NodeFrame:

$$\text{Artifact (}\mathtt{.rl}\text{)} = \text{Algorithm} + \text{Schedule} + \text{Proof}$$

---

Key Highlights in v0.1.0

1. Zero-Parse 128-Bit Binary Format (.rl) & Shorthand Symbolic Assembler (.rls)

• 64-byte RulHeader (RL_MAGIC = b"RUL\x00\x01\x00\x00\x00", FNV-1a/BLAKE3-64 graph integrity hash, 64-bit hardware capability_mask).
• 16-byte ArenaDescriptor Table: 64-byte cache-line-aligned Structure-of-Arrays (SoA) columnar memory regions.
• 16-byte ProofEntry Sidecar Table: Compile-time refinement proofs (SliceBounds, IndexInRange) eliminating runtime bounds checks.
• 16-byte NodeFrame Instruction DAG: [ opcode (u8) | type_lane (u8) | schedule_hint (u8) | proof_idx (u8) | token_op (u32) | in_a (u32) | in_b (u32) ].
• Token-Minimal .rls Symbolic Format: Compiles AI Agent symbolic shorthand (A0:f64x8[10000000], $0 = in A0 @1, ...) to binary .rl in ~7 microseconds.

2. Single-Pass $O(N)$ Linear Static Verifier (2.77 GB/s Verification Throughput)

• Verifies a 10,000-node .rl program in 57.79 µs (~5.78 ns / 128-bit node).
• Mathematically guarantees 100% absence of non-termination cycles, memory aliasing / use-after-consume (AffineConsume + shared ReadLease), buffer overflows (Bounds-Safe by Construction), and sandbox escapes (CapabilityMask).

3. 3-Tier Execution Engine, Closed-Loop Auto-Tuner & Zero-LLVM ELF64 AOT Compiler

• Tier 0 (execute_tier0_oracle): Reference columnar interpreter & AssertContract golden oracle.
• Tier 1 (execute_tier1_stencil): Vectorized columnar kernel stencils.
• Tier 2 (execute_tier2_fused & execute_tier2_with_zonemap): Whole-graph SIMD register fusion with 0 bytes of intermediate heap allocation, multi-core work partitioning, and $O(1)$ L1-cache tile skipping (ArenaZoneMap).
• Direct In-RAM & Standalone x86_64 ELF64 AOT Compiler (src/aot.rs): Emits vectorized AVX2 (256-bit ymm, 4x f64/cycle) standalone Linux executables (~817 bytes total file size!) in ~6.4 microseconds with zero external linker or LLVM dependency.
• Closed-Loop Hardware Auto-Tuner (autotune_schedule): Sweeps execution policies (AutoL1Tile, SimdStream, MultiCore, GpuDma) against hardware telemetry (GB/s, nanoseconds) and rewrites ScheduleHint bytes automatically.

4. Native AI Agent Ecosystem (rul-mcp, rul-cas, rul-ffi)

• rul-mcp Binary (src/bin/rul_mcp.rs): Built-in JSON-RPC 2.0 Model Context Protocol (MCP) server exposing rul_assemble_and_verify, rul_execute_and_tune, rul_compile_aot_elf64, and rul_inspect_binary directly to AI Agents.
• rul-cas (src/cas.rs): Content-Addressed Store & Ed25519-style cryptographic provenance registry for verified .rl modules.
• rul-ffi (src/ffi.rs): Zero-copy C ABI (rul_verify_bytes_ffi, rul_execute_f64_columns_ffi) and POSIX mmap Arena file bridge for Python/Node/C++/Arrow integration.

---

Production Benchmark Summary (10,000,000 f64 Records = 80 MB SoA)

Implementation	Median Latency	Effective Bandwidth	Speedup vs. C 8-Acc	Speedup vs. Legacy AoS
Legacy Imperative AoS + Vec::collect()	70.66 ms	1.13 GB/s	0.10x	1.00x
Idiomatic Rust SoA (filter().map().sum())	19.12 ms	4.18 GB/s	0.38x	3.70x
Hand-Written C/Rust 8-Acc SoA (1-Core)	7.32 ms	10.92 GB/s	1.00x	9.65x
Rul (.rl) Tier 2 Fused SIMD (1-Core)	5.91 ms	13.53 GB/s	1.24x	11.95x
Rul (.rl) Tier 2 Auto-MultiCore (All)	3.19 ms	25.04 GB/s	2.29x	22.12x
Rul (.rl) Tier 2 MultiCore + ZoneMap	1.55 ms	51.53 GB/s	4.72x	45.51x

---

Attached Release Assets & Cryptographic Provenance

• rul-v0.1.0-x86_64-unknown-linux-gnu.tar.gz: Prebuilt Linux x86_64 binaries (rul-bench, rul-mcp), canonical risk_pipeline.rl (192B), risk_pipeline.rls, standalone risk_pipeline_aot ELF64 binary (817B), and specification docs.
• WHITEPAPER_RUL_V0_1.md: Technical Whitepaper & Empirical Evaluation.
• PROOF_OF_AUTHORSHIP.sha256 & PROOF_OF_AUTHORSHIP.sha256.ots: Cryptographic SHA-256 Prior Art Manifest & OpenTimestamps Bitcoin Blockchain proof.
• SHA256SUMS.txt: SHA-256 checksums for all release assets.