Rul (.rl): A 128-Bit Schedule- and Proof-Carrying Binary SSA-DAG Programming Language and Execution Engine for Autonomous AI Agents

doi:10.5281/zenodo.23722094

← Atelier WHITEPAPER · ZENODO DOI 10.5281/zenodo.23722094 v0.4.0 DOI: 10.5281/zenodo.23722094

Livre blanc & évaluation empirique de Rul (.rl) — Zenodo DOI 10.5281/zenodo.23722094

Livre blanc technique, analyse architecturale depuis les premiers principes, méthodologie de benchmark colonnaire de 80 Mo et vérification cryptographique Prior Art SHA-256 pour Rul (.rl).

[0x01] RÉSUMÉ SCIENTIFIQUE

Rul (.rl) : Un langage de programmation binaire SSA-DAG 128 bits porteur d'ordonnancement et de preuves

Publié le: 2026-10-28 · https://doi.org/10.5281/zenodo.23722094

Les langages de programmation traditionnels (C, Go, Rust, Python) sont conçus autour des limites biologiques humaines : saisie clavier à faible bande passante (~40 bits/s) et lecture visuelle de code ASCII, ce qui impose une lourde taxe de sérialisation, d'analyse syntaxique, d'inférence de types et d'optimisation LLVM aux agents IA autonomes.

Rul (.rl) élimine le code source textuel comme représentation principale et le remplace par un SSA-DAG topologique binaire plat projeté en mémoire (mmap) où chaque instruction est une trame NodeFrame fixe de 128 bits (16 octets) encodant Algorithm + ScheduleHint + ProofIdx + AffineToken/ReadLease. Comme l'agent IA émet des indications d'ordonnancement et des témoins de sécurité explicites aux côtés de l'algorithme, le compilateur Rul n'effectue aucune inférence de type ni aucune recherche : un vérificateur linéaire O(N) en une passe garantit mathématiquement l'absence totale d'aliasing mémoire, d'use-after-consume, de débordement de tampon et de violation de bac à sable en ~5,78 ns/nœud, tandis que le moteur à 3 niveaux et le compilateur AOT x86_64 ELF64 fusionnent les pipelines colonnaires en boucles de registres en ~6,4 µs.

[0x02] FIRST-PRINCIPLES DECONSTRUCTION

Pourquoi les langages textuels humains sont un goulot d'étranglement pour les agents IA

Pipeline textuel classique (Rust / C++)

• L'IA sérialise son intention tensorielle interne en des milliers de caractères ASCII (pub fn, accolades, points-virgules).
• Le compilateur passe des secondes à analyser le texte, construire des AST et résoudre des problèmes NP-difficiles de Borrow Checker et d'allocation de registres.
• L'ordonnancement matériel (SIMD / tuilage de cache / threads) est enchevêtré dans la syntaxe des boucles impératives.

Pipeline binaire 128 bits Rul (.rl)

• L'IA émet directement des trames binaires de 16 octets (0 ms de parsing, 0 % d'erreur de syntaxe).
• Une seule boucle avant vérifie l'ordre SSA, les versions mémoire et les bornes en ~5,78 ns/instruction.
• Muter 1 octet (Octet 2 : schedule_hint) bascule l'exécution du SIMD monocœur vers MultiCore + ZoneMap.

[0x03] EMPIRICAL EVALUATION (80 MB / 10M F64)

Résultats des benchmarks empiriques (80 Mo / 10M f64)

IMPLÉMENTATION	MODE	LATENCE	BANDE PASSANTE	VS C 8-ACC
[A] AoS impératif + Vec::collect()	1 cœur AoS + Allocation sur le tas	70.66 ms	1.13 GB/s	0.10x
[B] Rust SoA idiomatique (filter().map().sum())	1 cœur Chaîne d'itérateurs SoA	19.12 ms	4.18 GB/s	0.38x
[C] C/Rust SoA à 8 accumulateurs écrit à la main	1 cœur 8 voies déroulées (Référence)	7.32 ms	10.92 GB/s	1.00x (Baseline)
[D] Rul (.rl) Tier 2 SIMD fusionné (0x11)	1 cœur Tuile L1 SIMD (SimdStream)	5.91 ms	13.53 GB/s	1.24x (1-Core vs 1-Core)
[E] Rul (.rl) Tier 2 MultiCore (0x12)	Tous les cœurs (Mutation d'1 octet d'ordonnancement)	3.19 ms	25.04 GB/s	2.29x (Schedule Byte)
[F] Rul (.rl) Tier 2 MultiCore + ZoneMap	Tous les cœurs + Saut O(1) des tuiles froides	1.55 ms	51.53 GB/s	4.72x (Peak Speedup)

[0x04] ACADEMIC CITATION

Citer Rul (.rl) dans vos recherches

@software{rul_2026_spec,
  author       = {Rul Core Architecture Team},
  title        = {{Rul (.rl): A 128-Bit Schedule- and Proof-Carrying Binary SSA-DAG Programming Language and Execution Engine for Autonomous AI Agents}},
  month        = oct,
  year         = 2026,
  publisher    = {Zenodo},
  version      = {0.4.0},
  doi          = {10.5281/zenodo.23722094},
  url          = {https://doi.org/10.5281/zenodo.23722094}
}

[0x05] CRYPTOGRAPHIC PRIOR ART (SHA-256 + OPENTIMESTAMPS)

Vérification de paternité & antériorité cryptographique (Prior Art)

Empreintes SHA-256 de la spécification principale et de l'implémentation Rust ancrées via OpenTimestamps sur la blockchain Bitcoin dans docs/prior_art/.

CHEMIN DU FICHIER	RÔLE ARCHITECTURAL	EMPREINTE SHA-256
docs/rul_spec_v0.md	Spécification officielle du format binaire .rl & du vérificateur O(N)	9174ff81b429b19785646f25707034a36b4ba7b4a7964b7e04ddbc31fda9d9c6
docs/WHITEPAPER_RUL_V0_1.md	Livre blanc technique & évaluation empirique (Zenodo DOI)	141ea3d9b348369b4e233746619fee443387e931c821fe2eb32b93f760571b98
docs/new_language_for_AI.md	Analyse architecturale de premiers principes pour les agents IA	88043cda84b7289e9fe26f4bc3547a58b994a91b1df8774bbc206dc6dba5504d
src/bytecode.rs	Définitions RulHeader 64o, ArenaDescriptor 16o, ProofEntry & NodeFrame 128 bits	3a8c780cf4181c936b303943eafa3729eba9e519cd9d55569c28f1f630f26c03
src/verifier.rs	Vérificateur statique linéaire O(N) en une passe (~5,78 ns/nœud)	feaa5ae7e94b2bede64772d1ce595286bed35ac2afc9be9b571836813a4eb11b
src/engine.rs	Moteur d'exécution à 3 niveaux, fusionneur de tuiles L1, ZoneMap & traceur boîte blanche	8037e2f718dc24d372a67111d9a6c5481ade4ff55a62d1b315b35c9ccf879bcf
src/aot.rs	Compilateur Linux x86_64 AVX2 ELF64 sans LLVM (~6,4 µs)	fe8eddae822fae0df6ea751aaa7919fc81675a7c169d2aadb4c3b9e6f05f27ac
src/mcp.rs	Serveur Model Context Protocol JSON-RPC 2.0 en mémoire sur stdio	c58faa2f0ac626412a6c8ef00ae67dabc85b863f4c0ba73c3e16a0ff909a91c6