Expanding Rul’s 128-bit proof-carrying binary engine (5.8ns/node O(N) verifier, 6.4µs ELF64 AOT) from columnar compute to general-purpose systems programming.
Rul (.rl — Rule-Carrying Unified Linear Graph) is a 100% open-source (MIT OR Apache-2.0), non-commercial 128-bit schedule- and proof-carrying binary programming language and execution engine designed from first principles for autonomous AI agents (https://github.com/rul-lang/rul | CERN Zenodo DOI: 10.5281/zenodo.23722094).
Why Phase 1 (v0.1) intentionally scoped to Columnar Data Processing: When inventing a brand-new binary programming language where programs are fixed 16-byte (128-bit) memory-mapped frames carrying Algorithm + ScheduleHint + ProofIdx + AffineToken, we deliberately restricted the initial v0.1 scope to columnar batch data processing (ArenaInput, CmpGt, Mul/Add, SelectZero, ReduceSum, Gather, ArenaSlice, ArenaMutate). This controlled domain allowed us to rigorously test and empirically validate our core thesis in 100% Safe Rust with zero external dependencies:
Zero-Syntax & Ultra-Compact Binary: A complete verified program is a 192-byte .rl graph that compiles directly to a standalone 817-byte Linux x86_64 ELF64 executable.
Compile & Verify 10,000x+ Faster than Go/Rust: Single-pass O(N) static verification runs in 5.78 ns/node (2.77 GB/s verification throughput), and zero-LLVM direct machine-code emission finishes in 6.38 microseconds.
Faster than Hand-Written C with Mathematical Safety: On a 10,000,000-row f64 benchmark pipeline, Rul’s fused 8-accumulator AVX2 + Zone-Map engine executes in 1.55 ms (51.53 GB/s) versus 7.32 ms for hand-unrolled 8-accumulator C, with 0 bytes of intermediate heap allocation and 100% compile-time elimination of out-of-bounds, use-after-consume, and unauthorized syscall bugs.
What this grant funds next — Expanding Rul from Columnar Compute into a Full General-Purpose Systems Language like Rust and Go: Having proven in v0.1 that 128-bit proof-carrying binary graphs work and outperform traditional languages on columnar workloads, we are now ready to expand Rul beyond columnar pipelines into a general-purpose systems and concurrent programming language comparable to Rust and Go, while preserving single-pass O(N) verification and microsecond compilation.
Over the next 6 months, we will execute a four-milestone technical roadmap transitioning Rul from a columnar compute engine (v0.1) to a general-purpose proof-carrying systems language (v1.0):
Milestone 1 — General-Purpose Control Flow, Functions & Algebraic Data Types (Months 1–2): Expand the 16-byte NodeFrame ISA beyond columnar SIMD arrays to support general-purpose scalar/struct types, UTF-8 strings, hash maps, structured control flow (RegionLoop with mandatory termination fuel/variant proofs, SelectBranch), and modular function calls while preserving topological O(N) single-pass verification.
Milestone 2 — Rust-Grade Linear/Affine Ownership & Lifetime Proofs in O(N) Time (Months 2–3): Generalize Rul’s 32-bit TokenOp (AffineConsume) and 16-byte ProofEntry sidecar table to verify general heap allocations, struct field borrows, and zero-copy slice lifetimes in a single forward pass—giving AI-generated systems code the memory safety of Rust without the multi-second constraint-solving bottleneck of rustc.
Milestone 3 — Go-Style Deterministic Concurrency & Capability-Gated Systems I/O (Months 4–5): Introduce lightweight, deterministic structured concurrency (typed channels and work-stealing tasks) and fine-grained CapabilityMask enforcement for filesystem, network socket, and subprocess syscalls, ensuring autonomous AI agents executed via rul-mcp cannot escalate privileges, leak data, or cause data races.
Milestone 4 — Multi-Architecture Zero-LLVM Backends (x86_64, ARM64, WASI) & Formal Soundness Proofs (Month 6): Extend src/aot.rs to emit standalone native binaries for Linux/macOS/Windows across x86_64 and AArch64 (ARM64) plus deterministic WebAssembly (WASI), backed by Kani Rust Verifier model-checking proofs and 24/7 differential fuzzing.
General-Purpose Language Benchmark Suite (Rul vs. Rust vs. Go vs. C): Publish an open-source, reproducible benchmark suite demonstrating Rul v1.0 executing not only columnar analytics, but general-purpose systems tasks (HTTP/JSON-RPC servers, concurrent worker pipelines, graph algorithms, and string/struct processing) with sub-100-microsecond compilation, <10 ns/node static verification, and runtime performance matching or beating Rust and Go.
Zero Uncaught Memory or Capability Violations: 100,000,000+ iterations of coverage-guided differential fuzzing (cargo-fuzz / proptest) and Kani formal verification over src/verifier.rs confirming that no malformed or adversarial .rl binary can trigger undefined behavior, buffer overflows, data races, or unauthorized syscalls.
Ecosystem Adoption by AI Agent Frameworks: Turnkey integration of rul-mcp (Model Context Protocol server) and crates.io releases enabling Claude, OpenAI, and open-weight coding agents to synthesize and execute verified general-purpose .rl programs in production.
Rul is a non-commercial, 100% open-source public good developed in Vietnam with ultra-low overhead ($50/hour engineering rate, $0 office/administrative overhead):
At Minimum Funding ($15,000 USD — 3 months / 300 hours): Deliver Milestones 1 and 2—expanding Rul from columnar data processing to general-purpose structs, control flow, modular functions, and Rust-style affine memory ownership verification in O(N) time.
At Full Target Goal ($50,000 USD — 6 months / 1,000 hours): Deliver all 4 Milestones ($46,000 for 920 hours of full-time compiler & formal verification engineering + $4,000 for dedicated bare-metal x86_64/ARM64 continuous fuzzing & Kani/SMT verification servers), completing Go-style deterministic concurrency, capability-gated OS I/O, and multi-architecture native binary emission.
Tran Trong Tri (Tymon Tran) — Principal Creator & Systems Architect (LinkedIn | GitHub | Zenodo DOI).
I single-handedly designed and implemented the entire Rul v0.1.0 production codebase in 100% Safe Rust with zero external runtime dependencies, including:
The 128-bit zero-copy binary SSA-DAG format and symbolic assembler (src/bytecode.rs, src/transpiler.rs).
The single-pass O(N) linear static verifier (src/verifier.rs, 5.78 ns/node).
The standalone zero-LLVM x86_64 AVX2 JIT and 817-byte ELF64 AOT native machine-code compiler (src/aot.rs, 6.38 µs).
The 3-tier execution engine and hardware-aware auto-tuner achieving 51.53 GB/s on 10M rows (src/engine.rs).
The content-addressed intrinsic store (src/cas.rs), C-ABI FFI bridge (src/ffi.rs), and JSON-RPC 2.0 MCP server (src/mcp.rs).
Risk 1 — Preserving O(N) Single-Pass Verification While Adding General Control Flow & Loops: Arbitrary cyclic control-flow graphs (CFGs) normally require super-linear dataflow analysis. Mitigation: Instead of unstructured goto jumps, Rul v1.0 uses structured RVSDG (Regionalized Value-State Dependence Graph) loop and branch regions with explicit fuel/variant bounds and affine token threading, mathematically preserving single-pass O(N) verification.
Risk 2 — AI Agent Ergonomics Without Human Syntax: LLMs are pre-trained on text languages like Python and Rust. Mitigation: Rul provides a token-minimal symbolic shorthand (.rls) and typed JSON-RPC MCP tool schemas (rul-mcp) with deterministic per-node error diagnostics (VerifyDiagnostic { node_idx, kind }), allowing existing LLMs to emit valid general-purpose graphs on the first turn without fine-tuning.
$0 USD received in the last 12 months. The entire Rul v0.1.0 compiler, verifier, AOT engine, and whitepaper have been 100% self-funded by the creator. We have concurrent non-dilutive grant applications under review at NLnet Foundation (Restack Fund), Foresight Institute, EA Funds, Sovereign Tech Agency, and ARIA (UK).
There are no bids on this project.
Comments
No comments yet. Sign in to create one!