How Ring++ works — and how it is measured

The pieces

• The parser. Youssef Saeed's tree-sitter grammar for Ring, vendored. It gives every node its exact span, which is what lets the compiler point at the statement it refuses.
• The compiler. Ring source to bytecode: name resolution done once, at compile time; type inference over the whole program; methods resolved to slots where the receiver is known; and a refusal, with its reason, for anything it cannot compile correctly. rnxc check is the same compiler reporting instead of running.
• The VM. 16-byte tagged values, contiguous lists, strings passed by reference, lists and objects copied at assignment as Ring's semantics require; register windows for calls; threaded dispatch; mimalloc underneath.
• The native interface. A small ABI in Zig. Softanza's engine — 89 domains: strings, Unicode, regular expressions, graphs, neural models, GPU, sound and more — is built for Ring++ from its own unchanged source, with one file swapped. Zip is built in.
• The compiled image. A program is compiled once; later runs start from the image: Softanza's 614 files in 0.1 s instead of 10.

The oracle

Ring 1.27's VM source is vendored verbatim, under its MIT licence, and built with the same Zig toolchain on five platforms. That build — not an installation anyone else controls — is what every comparison is made against. It is never shipped and never the product; it exists so that every claim of compatibility can be checked.

What is measured, before every release

• The probes. 159 programs, each pinning one rule of Ring, byte for byte against the oracle: on Windows in the optimised and the safety-checked builds, and on Linux.
• The census. Softanza's base library compiled whole: 118,640 statements, every one compiled — among them a 3,909-line function with 631 locals, whose locals share registers because one apiece does not fit the window.
• The wide clock. 5,112 Ring programs — Softanza's tests and examples — run on both runtimes. The oracle runs each twice first, so a line it does not reproduce from itself (a time, a random draw) is never counted against Ring++. 3,567 agree on every remaining line on Windows, 3,753 on Linux, on 2.0.2's compiler; most of the rest differ only on the line that reports how long the program took.
• Assertion parity. Every check that passes on Ring must pass on Ring++. Counting every check Softanza's tests print, [PASS] and [OK] alike, Ring++ passes 12,924 of Ring's 13,008 on Windows and 12,170 of 12,255 on Linux, against Softanza as of 4 October 2026 (Windows on 2.0.3: the programs its one change reaches were run again; Linux on 2.0.2, every function but that one compiling to the same code). The rest is named: 81 sit in three test files that read a global without its $ inside a function, which Ring++ refuses to compile — corrected in Softanza since, they pass every check; a handful measure time or memory; and on Linux one is a cluster test that does not finish under Ring++. Until 17 October 2026 this count read [PASS] lines only, and said 8,540 of 8,540: true of those checks, and silent about the 4,468 written as [OK].

And four rules for every number: no claim without a measurement; minima over repetitions, never one run; the same answer before any speed is quoted; and every speed-up stated with the pattern it makes slower. The first measurements of the VM, and what flatters them, are in NOTES.md.

The commands

rnxc program.ring            run it (the first run compiles; later runs start from the image)
rnxc check program.ring      report what Ring would only find when the line runs
rnxc census program.ring     what compiles, what is refused, and why
rnxc fmt program.ring        the canonical text of a Ring file
rnxc graph program.ring      the resolved call graph, as the compiler bound it
rnxc dump --json file.ring   the lossless parse tree