You're pledging to donate if the project hits its minimum goal and gets approved. If not, your funds will be returned.
$50,000 left to reach the funding goal.
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).