rul .rl
[0x00..0x3F] magic = b"RUL\x00\x01\x00\x00\x00" · 128-Bit Binaire IR
Release v0.4.0 (2026-11-07) ↗

De 128-Bit Binaire Programmeertaal voor AI-Agenten.

AI denkt in getallen en CPU's draaien binair — toch dwingen C, Go en Rust AI om menselijke tekst te typen en seconden te wachten tot een compiler raadt wat er bedoeld werd. Rul (.rl) schrapt die tekstuele tussenpersoon: AI genereert vaste binaire bouwstenen van 16 bytes die vooraf het Algoritme, het CPU-Schema en het Geheugenveiligheidsticket bevatten. Resultaat: 5.8 ns veiligheidsverificatie, 6.4 µs zelfstandige compilatie en 4.72x snellere uitvoering dan handgeschreven C.

FIRST-PRINCIPLES IN 10 SECONDEN · SCHRAP DE TEKSTUELE TUSSENPERSOON
✗ OUDE MANIER (C / Go / Rust) AI Denkt (Getallen) → Typt Menselijke Tekst → Compiler Parset & Raadt Intentie (Seconden) → Machinecode (0/1)
✓ RUL (.rl) FIRST-PRINCIPLES AI Denkt (Getallen) → Genereert 16-Byte Binaire Bouwsteen (5.8 ns Bewijs + 6.4 µs Compilatie) → Draait 4.72x Sneller dan C
16-Byte Binaire Bouwsteen (0ms Tekst-Parse) + 6.4 µs Native ELF64 (Zonder LLVM) + 5.8 ns Veiligheidsbewijs (O(N) Lineair)
# 1. Install standalone rul binary (0 rustc/LLVM runtime deps)
$ curl -fsSL https://raw.githubusercontent.com/rul-lang/rul/main/install.sh | sh

# 2. Scaffold, O(N) verify in ~5.8ns/node, compile 817B ELF64 & trace
$ rul new my-ai-pipeline && cd my-ai-pipeline
$ rul check   # ✓ Verified 7 SSA nodes in 0.04 µs (CAP_NONE = 0x0)
$ rul run     # ✓ Compiled 817-byte ELF64 in 6.4 µs -> Output: 77999800.0
$ rul trace   # ✓ White-Box Inspector: #0..#6 (NaN/Inf = 0)
Inspecteer 16-Byte Frame ↓ Lees v0.4 Spec Whitepaper (DOI) ↗
LIVE .RL BINAIRE IMAGE · 7 SSA-NODES = 208 BYTES -> 817-BYTE ELF64 CAP_NONE=0x0

Klik hieronder op een instructieframe van 16 bytes om de bits, het verifierbewijs en de trace te decoderen:

RulHeader
64 Bytes (0x00..0x3F)
Arena[0] + Proof[0]
32 Bytes (0x40..0x5F)
NodeFrame[0..6]
112 Bytes (7 × 16B)
#0 ArenaInput
01 18 11 00
#1 ConstF64
02 11 11 00
#2 CmpGt
14 38 11 00
#3 Mul
12 18 12 00
#4 SelectZero
15 18 11 00
#5 ReduceSum
21 11 11 00
#6 AssertContract
40 11 11 00
Artifact (.rl) = Algorithm + Schedule + Proof ✓ 5.78 ns/node
[0x40] 128-Bit Frame
16 Bytes

Elke Instructie Is een Vaste Binaire Bouwsteen · 0 ms Tekst-Parsing

[0x50] per instructie
5.78 ns

Direct Geheugen- & Bereikbewijs (Enkele O(N) Doorgang)

[0x60] native compilatie
6.4 µs

Zelfstandige Linux x86_64 ELF64-Binary Zonder LLVM

[0x70] 4.72x vs C
51.53 GB/s

10M Getallen (80 MB) Versneld door een 1-Byte Mutatie

[0x80] INTERACTIEVE 128-BIT WERKBANK

Één 16-Byte Instructie = Algoritme + Schema + Bewijs

Selecteer een instructienode (#0..#6) of klik op een byte (0..15) om het 8-bit binaire register, het O(N) veiligheidscertificaat en de live white-box uitvoeringstrace te inspecteren.

Algoritmestrook (Wat te berekenen: Opcode / Operanden) Schemastrook (Hoe uit te voeren: SIMD / MultiCore) Bewijsstrook (Veiligheid: Versieticket / Grenzen)
NODE #3 ($n3) node $n3 = Mul f64x8 fg=1 pol=simd proof=0 tok=pure a=$n0 b=$n0
16 BYTES = 128 BITS
8-BIT REGISTEROVERZICHT · BYTE 2 (b16..b23) 0x12
0 2^7
0 2^6
0 2^5
1 2^4
0 2^3
0 2^2
1 2^1
0 2^0
Veld: schedule_hint Type: u8
✓ O(N) Verifier-invariant Gecontroleerd bij het Laden (~5.78 ns) (fusion_group << 4) | exec_policy

Orthogonale hardware-schedule byte: het muteren van 0x11 (SimdStream) -> 0x12 (MultiCore) wijzigt de CPU-uitvoering zonder veiligheidsbewijzen aan te tasten.

Node #3: Elementgewijs 8-baans vectorkwadraat ($n0 * $n0) gefuseerd in L1-cacheregisters zonder tussenliggende heap-allocatie.
Symbolische Assembly-weergave (src/main.rls — 208 B in .rl) ~8.8 µs assemble
cap 0x0
arena 0 len=4096 lane=f64x8 mut=false align=64 ver=1
output $n6
White-Box Uitvoeringstracer (rul trace — 7 SSA-Nodes) Klik op een rij om het 16-byte binaire frame & de assembly te synchroniseren
NODEOPCODEKINDLENMINMAXSUM/TRUESNANSAMPLE[0..4]
#0ArenaInputColumnF6440960.5000249.5000504608.00000[0.500, 1.500, 2.500, 3.500]
#1ConstF64Scalar1100.0000100.0000100.00000[100.000]
#2CmpGtColumnMask40960.00001.00002400.00000[0.000, 0.000, 0.000, 0.000]
#3MulColumnF6440960.250062250.250083627904.00000[0.250, 2.250, 6.250, 12.250]
#4SelectZeroColumnF6440960.000062250.250077999800.00000[0.000, 0.000, 0.000, 0.000]
#5ReduceSumScalar177999800.000077999800.000077999800.00000[77999800.000]
#6AssertContractScalar177999800.000077999800.000077999800.00000[77999800.000]
[0x100] 1-BYTE HARDWARE-SCHEDULE MUTATIE

Muteer 1 Byte (Byte 2). Versnel 4.72x Voorbij Handgeschreven C.

Echte workload: 10.000.000 drijvende-kommagetallen (80 MB array) — filter waarden > 1000.0, kwadrateer ze en tel ze op tot één enkel resultaat. Klik hieronder om Byte 2 (schedule_hint) te muteren: het algoritme blijft 100% identiek, terwijl de uitvoering daalt van 5.91 ms naar 1.55 ms:

ACTIEVE BYTE 2 (schedule_hint): 0x12 + ZM bits[16..23] = 0001 0010
1.55 ms · 51.53 GB/s (4.72x vs C)

fg=1 pol=multicore + ArenaZoneMap: Combineert MultiCore L1-tiling met blok-min/max metadata (ArenaZoneMap) om koude tiles van 1.024 elementen in O(1) over te slaan zonder DRAM-leesacties.

[A] Imperatief AoS + Vec::collect()
70.66 ms 1.13 GB/s
[B] Idiomatische Rust SoA (filter().map().sum())
19.12 ms 4.18 GB/s
[C] Handgeschreven C/Rust SoA met 8 Accumulatoren
7.32 ms 10.92 GB/s
[D] Rul (.rl) Tier 2 Gefuseerde SIMD (0x11)
5.91 ms 13.53 GB/s
[E] Rul (.rl) Tier 2 MultiCore (0x12)
3.19 ms 25.04 GB/s
[F] Rul (.rl) Tier 2 MultiCore + ZoneMap
1.55 ms 51.53 GB/s
Diepe Pipeline-bewijs: BM-HORNER-50 (50-Staps Polynoom · 104 SSA-Nodes · 80 MB)

De lineaire YMM-registerallocator in src/aot.rs compileert een zelfstandige ELF64-binary van 3.872 bytes in ~20.4 µs en voert deze uit in 106.58 ms — even snel als handgeschreven C/Rust met 8 accumulatoren (107.96 ms) zonder LLVM.

[0x140] VIER FIRST-PRINCIPLES MECHANISMEN

Eenvoudig in First Principles. Wiskundig Exact in Silicium.

Traditionele talen compileren traag omdat de machine menselijke tekst moet lezen en je intentie moet raden. Rul elimineert al het giswerk via vier vanzelfsprekende mechanismen:

01 · BINAIRE ENIGE BRON VAN WAARHEID src/bytecode.rs

1. Nul Tekst-Parsing (0% Syntaxfouten)

In plaats van AI te dwingen duizenden tekens te typen die gevoelig zijn voor ontbrekende puntkomma's, genereert AI rechtstreeks binaire bouwstenen van 16 bytes (of assembleert platte .rls-listings in ~8.8 µs). Een 7-staps pipeline die 10 miljoen getallen verwerkt is slechts 208 bytes in .rl en compileert naar een zelfstandige Linux ELF64-executable van 817 bytes.

1. RulHeader 64 Bytes (64B-aligned)
2. ArenaDescriptor Table arena_count × 16 Bytes
3. ProofEntry Sidecar Table proof_count × 16 Bytes
4. NodeFrame Instruction DAG node_count × 16 Bytes
02 · LINEAIR EIGENDOM IN O(N) src/verifier.rs

2. Geversioneerde Geheugentickets (Rust-veiligheid in Nanoseconden)

Zie elke geheugenbuffer (Arena) als een kamer met een genummerd ticket dat begint bij versie 1. Meerdere instructies kunnen versie 1 tegelijk lezen (ReadLease 0b01). Zodra een instructie gegevens in-place wijzigt (AffineConsume 0b10), gaat de kamer naar versie 2 — elke latere instructie met een verouderd versie 1-ticket wordt aan de deur geweigerd in 5.78 ns zonder trage Borrow Checker.

TOKEN_OP (32-BIT) = [mode: 2b | arena_id: 14b | version: 16b]
0b01 ReadLease(arena=0, ver=1) ✓ Gedeeld Lezen (ver blijft 1)
0b10 AffineConsume(arena=0, ver=1) → Muteer & Verhoog ver = 2
Reuse stale ReadLease(arena=0, ver=1) ✗ Weiger: StaleOrConsumedToken
03 · ZERO-TRUST SANDBOX & GRENZEN ProofEntry + CapMask

3. Voorafgaande Grenscertificaten & Hardware-Toestemmingsschakelaar

Kolommen van gelijke lengte draaien op volle snelheid zonder grenscontroles in de binnenste lus (TRIVIAL_BY_SHAPE). Het opdelen van een array (ArenaSlice) of springen op index (Gather) vereist het tonen van een 16-byte grenscertificaat (ProofEntry) bij het laden. En wanneer de hardware-toestemmingsschakelaar (CapabilityMask) op 0x0 staat, wordt de binary fysiek geblokkeerd om het netwerk of de schijf aan te raken.

proof_idx == 0 (90%+ nodes): TRIVIAL_BY_SHAPE (0 runtime checks)
proof_idx > 0 (ArenaSlice / Gather): lo <= hi <= effective_target_len
RulHeader.capability_mask = 0x0: CAP_NONE (Pure Compute Sandbox)
04 · WHITE-BOX AUDITEERBAARHEID rul trace & decompile

4. Röntgen White-Box Transparantie (Nooit een Black Box)

Mensen hoeven nooit binaire code te typen om 100% de controle te houden: engineers bepalen de datalayout (ArenaDescriptor), hardwaretoestemmingen (CapabilityMask) en uitvoercontracten (AssertContract); AI regenereert de .rl-binary in microseconden. Voer op elk moment rul decompile uit voor leesbare tekst of rul trace om exacte min, max, som en NaN=0 bij elke stap te inspecteren.

Menselijk Contract → AI Regenereert .rl
Verifieer + Compileer in ~12 µs totaal
29-Opcode Spec →
[0x180] SYSTEEMMATRIX & AGENT MCP

C vs. Go vs. Rust vs. Rul (.rl)

Architecturale vergelijking over parse-overhead, geheugenveiligheidscomplexiteit, grenscontroles, compilatielatentie en sandbox-beveiliging.

DIMENSIEC (clang -O3)Go (gc)Rust (rustc + LLVM)Rul (.rl) v0.4
Primaire AuteurMenselijke programmeurMenselijke engineeringteamsMenselijke systeemengineersAI-Agenten (met door mensen auditeerbare tools)
ArtefactformaatTekst (.c, .h)Tekst (.go)Tekst (.rs)Platte Binary .rl (16-Byte Instructies)
Parse-OverheadHoogGemiddeldZeer Hoog (Macro's, AST)0 ms (Directe zero-copy binaire mmap)
GeheugenveiligheidGeen (Handmatige pointers)Garbage Collector (Runtime-pauzes)Borrow Checker (Constraint solver)Geversioneerde TokenOp (O(1) controle per node)
GrenscontroleOngecontroleerd (Buffer overflows)Runtime-vertakking per toegangRuntime-vertakking (tenzij weggelaten)Laadtijd-Shape + ProofEntry hulptabel
Verificatie- + CompilatietijdSecondenSub-seconde tot secondenSeconden tot minuten~5.8 ns/node Verificatie + ~6.4 µs ELF64 AOT
Sandbox-BeveiligingVolledig OS-procesVolledig OS-procesVolledig OS-proces (unsafe crates)64-Bit CapabilityMask in Bestandsheader
STDIO JSON-RPC 2.0 · src/mcp.rs

Ingebouwde Model Context Protocol Server (rul-mcp)

Zelfstandige stdio JSON-RPC 2.0 server zonder afhankelijkheden die 6 native tools voor verificatie, differentieel testen, autotuning en AOT-compilatie rechtstreeks beschikbaar stelt aan autonome AI-agenten.

GET /.well-known/mcp.json ↗
rul_assemble_and_verify ~8.8 µs + 5.8 ns/node
(rls_source: string) -> VerifiedSummary + .rl hex

Assembleert symbolische .rls-instructies naar een 128-bit binaire .rl-image en voert de single-pass O(N) statische verifier uit.

rul_test_differential Tier 0 == Tier 1 == Tier 2
(rls_source: string, arenas: ArenaData[]) -> DiffReport

Voert het geverifieerde programma uit over Tier 0 (Orakel), Tier 1 (Stencil) en Tier 2 (L1 Fused) om bitwise/ULP-equivalentie te bewijzen.

rul_autotune_schedule 1-Byte Sweep
(rls_source: string) -> Optimal ScheduleHint + Telemetry

Doorzoekt AutoL1Tile (0x10), SimdStream (0x11) en MultiCore (0x12) beleid en selecteert de hoogste GB/s hardware-beloningsscore.

rul_compile_standalone ~6.4 µs ELF64
(rls_source: string) -> Standalone Linux x86_64 ELF64

Genereert een zelfstandige Linux x86_64 AVX2 ELF64-executable zonder afhankelijkheden (628 B – 1.037 B) met lineaire YMM-registerallocatie.

rul_trace White-Box Inspector
(rls_source: string) -> NodeTraceRow[0..N-1]

Retourneert exacte per-node min, max, som/waarzijden, NaN/Inf-aantal en sample[0..4] telemetrie over elke SSA-instructie.

rul_cas_intrinsics 64-Bit FNV-1a CAS
(op: sort | hash_join | group_by | simd_scan) -> CasHash

Voert geverifieerde I64/U8 content-addressed kernels uit (sort, hash_join, group_by, simd_scan_byte) in RulCasStore.

[0x1C0] ROADMAP NAAR v1.0

Van Geverifieerde Kolom-Engine (v0.4) naar Algemene Systeemtaal (v1.0)

We hebben v0.1–v0.4 beperkt tot array- en vector-pipelines (29 opcodes) om het 16-byte binaire formaat eerst op echt silicium te bewijzen. Over vier mijlpalen breidt Rul uit om Rust en Go te vervangen voor door AI gegenereerde systeemsoftware:

Bekijk Volledige Technische Roadmap & Niet-Doelen →
v0.1.0 → v0.4.0 Opgeleverde Productie-Baseline
✓ PRODUCTIE

29-Opcode Kolom SSA-DAG Kern, White-Box Tracer & Lineaire AVX2 ELF64 AOT

Bewees het 16-byte binaire instructieformaat, de single-pass O(N) verifier (~5.8 ns/node), de 3-laags uitvoeringsengine, de rul-mcp server en de LLVM-vrije native Linux ELF64-compiler (~6.4 µs) op echte hardware.

  • [1] 64-byte RulHeader, 16-byte ArenaDescriptor, 16-byte ProofEntry en 16-byte NodeFrame over 29 opcodes.
  • [2] Verliesvrije .rls <-> .rl symbolische assembler, zelfstandige rul CLI, rul-bench en 6-tool rul-mcp server.
  • [3] Lineaire YMM-registerallocator (ymm2..ymm13) die 51.53 GB/s (4.72x sneller dan C) behaalt op arrays van 80 MB.
v0.5 Mijlpaal 1 (Maanden 1–2)
● IN UITVOERING

Algemene Control Flow, Functies & Samengestelde Datatypen

Breid de 16-byte instructieset uit voorbij numerieke arrays ter ondersteuning van algemene scalairen, structs, enums, UTF-8 strings, hash maps, voorwaardelijke vertakkingen en lussen met bewezen beëindiging.

  • [1] Eersteklas ondersteuning voor i64, i32, u8, f32, structs met vaste layout, algebraïsche gelabelde unions, gevalideerde UTF-8 strings en arena hash maps.
  • [2] SelectBranch: voorwaardelijke vertakking waarbij beide takken moeten samenkomen op een identieke geheugenversiestatus (gecontroleerd in O(1)).
  • [3] RegionLoop & Call: begrensde lussen met ProofEntry beëindigingscertificaten en modulaire functies die worden geverifieerd zonder het hele programma te inlinen.
v0.6 – v0.7 Mijlpaal 2 (Maanden 2–3)
○ GEPLAND

Rust-Niveau Heap-Eigendom & Struct-Lifetimes in O(N) Tijd

Verbind 32-bit TokenOp-versies en 16-byte ProofEntry-certificaten van platte arrays naar regiogebaseerde heap-allocaties en struct-veldlezingen.

  • [1] Deterministische regio-heap-allocatie en -deallocatie gekoppeld aan lineaire eigendomstokens zonder GC en zonder malloc/free-fragmentatie.
  • [2] Ondersteunende ProofEntry-certificaten voor disjuncte struct-veldmutaties en zero-copy sub-slice lifetimes gecontroleerd in O(1) per instructie.
  • [3] Volledige bescherming tegen use-after-free, double-free en aliasing zonder secondenlange borrow-checker constraint solving.
v0.8 – v0.9 Mijlpaal 3 (Maanden 4–5)
○ GEPLAND

Go-Stijl Deterministische Concurrency & Capability-Gecontroleerde OS I/O

Introduceer lichtgewicht taken, eigendomsoverdragende kanalen en fijnmazige capability-bits in de header die bestands-, netwerk- en processyscalls beheren.

  • [1] Het verzenden van een buffer over een getypeerd kanaal voert een AffineConsume uit op het verzendertoken en draagt het eigendom over aan de ontvanger — wat dataraces bij het laden voorkomt zonder GC.
  • [2] Breid het 64-bit RulHeader.capability_mask uit om bestandssysteem-lees/schrijfacties, netwerksockets, timers en subprocessen te beveiligen.
  • [3] Een .rl-binary met CAP_NONE (0x0) wordt wiskundig geblokkeerd om enige netwerk- of schijfaanroep te doen voordat de uitvoering begint.
v1.0 Mijlpaal 4 (Maand 6)
○ GEPLAND

Multi-Architectuur Native Backends (x86_64, ARM64, WASI) & Formele Correctheidsbewijzen

Genereer zelfstandige executables voor Linux, macOS, Windows en WebAssembly zonder LLVM, ondersteund door Kani model checking en een v1.0 conformiteitssuite van 50 programma's.

  • [1] LLVM-vrije native codegeneratie voor x86_64 en AArch64 (ARM64) op Linux, macOS en Windows, plus deterministische WASI-modules.
  • [2] Bounded model-checking bewijzen (Kani) en continue differentiële fuzzing over de binaire decoder, O(N) verifier en native codegen.
  • [3] Bevroren .rl v1.0 binaire specificatie en openbare conformiteitstestsuite van 50 programma's.
[0x1F0] DIRECTE TECHNISCHE ANTWOORDEN (AEO / FAQ)

Veelgestelde Vragen — Van Begrijpelijke Taal tot Diepe Systemen

Heldere first-principles uitleg gecombineerd met exacte empirische metingen voor engineers, onderzoekers en AI-antwoordmachines.

Q01 Wat is Rul (.rl) en waarom gebruikt het een binair formaat van 16 bytes in plaats van menselijke tekst? +
AI denkt in getallen en CPU's draaien binair — toch dwingen talen als C, Go en Rust AI om duizenden menselijke woorden te typen en seconden te wachten tot een compiler (rustc/LLVM) die tekst weer terugvertaalt naar binaire code. Rul (.rl) schrapt de menselijke tekstuele tussenpersoon: AI-agenten genereren vaste 16-byte (128-bit) binaire bouwstenen die vooraf het Algoritme, het CPU-Schema en het Geheugenveiligheidsticket bevatten — wat tekst-parsing elimineert (0 ms) en zelfstandige Linux ELF64-executables compileert in ~6.4 µs.
Q02 Hoe verifieert Rul geheugenveiligheid op Rust-niveau in ~5.8 ns per instructie zonder een trage borrow checker? +
Zie elke geheugenbuffer (Arena) als een kamer met een genummerd versieticket dat begint bij versie 1. Meerdere instructies kunnen tegelijkertijd versie 1 lezen met een gedeelde ReadLease (0b01). Wanneer een instructie de buffer in-place wijzigt via AffineConsume (0b10), controleert deze of de buffer muteerbaar is en verhoogt de kamer naar versie 2. Elke latere instructie met een verouderd versie 1-ticket wordt aan de deur geweigerd in O(1) tijd tijdens één enkele voorwaartse doorgang (~5.78 ns/node) — er is geen borrow-checker solver van meerdere seconden nodig.
Q03 Als mensen geen .rl binaire bestanden met de hand schrijven, hoe debuggen en onderhouden engineeringteams Rul-systemen dan? +
Mensen houden 100% de controle zonder binaire code te typen — net zoals artsen röntgenfoto's lezen zonder ze met de hand te tekenen: (1) Mensen stellen vooraf de regels op — engineers definiëren dataschema's (ArenaDescriptor), hardware-toestemmingsschakelaars (64-bit CapabilityMask) en acceptatiecontroles (AssertContract), terwijl AI de geverifieerde .rl-binary in microseconden regenereert; (2) Direct leesbare tekst via `rul decompile` zet elk .rl-bestand terug om naar symbolische .rls-assembly; (3) Röntgeninspectie via `rul trace` print de exacte min, max, som, NaN/Inf-aantal en sample[0..4] waarden bij elke instructiestap.
Q04 Waarom is de Rul-toolchain geïmplementeerd in Rust als Rul ontworpen is om menselijke teksttalen voor AI-agenten te vervangen? +
Elke nieuwe systeemtaal vereist een initiële gasttaal voor zijn bootstrap-compiler — net zoals de eerste C-compiler in assembly werd geschreven en de eerste Rust-compiler in OCaml. We hebben de Rul-verifier, de 3-laags uitvoeringsengine en de native ELF64-compiler gebouwd in afhankelijkheidsvrije Rust onder #![forbid(unsafe_code)]. Zodra de zelfstandige `rul`-binary is geïnstalleerd, verifiëren, compileren en draaien gebruikers en AI-agenten .rl-programma's rechtstreeks zonder rustc, Cargo of LLVM nodig te hebben.
Q05 Hoe bereikt Rul 51.53 GB/s (4.72x sneller dan handgeschreven C) door één enkele byte te muteren? +
In Rul staat hardware-scheduling (Byte 2: schedule_hint) los van de algoritmelogica (Byte 0: opcode). Op een 80 MB (10.000.000 f64) filter-kwadraat-som pipeline fuseert single-core Rul (`0x11 SimdStream`) alle bewerkingen in L1-cacheblokken van 1.024 elementen in AVX2 YMM-registers, met een looptijd van 5.91 ms tegenover 7.32 ms voor handgeschreven C met 8 accumulatoren (1.24x sneller). Het muteren van Byte 2 van 0x11 naar 0x12 (`MultiCore`) parallelliseert die L1-tiles over alle CPU-cores (3.19 ms, 2.29x), en het inschakelen van `ArenaZoneMap` blok-min/max metadata slaat koude tiles in O(1) over om te eindigen in 1.55 ms (51.53 GB/s, 4.72x sneller dan 1-core C en 45.51x sneller dan imperatief AoS).
Q06 Kan Rul Rust en Go vervangen voor algemene backend- en systeemsoftware? +
Ja — dat is exact het doel van de v1.0-roadmap met vier mijlpalen: Mijlpaal 1 (v0.5) voegt i64/i32/u8/f32, structs, gelabelde unions, UTF-8 strings, hash maps, O(1)-geverifieerde SelectBranch-condities en RegionLoop-iteratie met bewezen beëindiging toe; Mijlpaal 2 (v0.6–0.7) breidt TokenOp en ProofEntry uit naar regiogebaseerde heap-allocaties en struct-veldlezingen; Mijlpaal 3 (v0.8–0.9) introduceert Go-stijl lichtgewicht taken en eigendomsoverdragende kanalen plus fijnmazige CapabilityMask OS-syscalls; Mijlpaal 4 (v1.0) levert LLVM-vrije native backends voor x86_64, ARM64 en WASI ondersteund door formele Kani-correctheidsbewijzen.