Project
Renyi Design Decisions, Round 1#
Every design decision with the options weighed and the reason, appended round by round; a reversal is a new entry.
On this page
- 0. Tensions and the trade-offs taken
- A. Positioning
- B. Types and strictness
- C. Syntax
- D. Constraints that serve LLM readers and writers
- E. Runtime
- F. Interoperability
- G. Modules, packages, standard library
- H. Implementation
- I. Naming and clarifications
- J. Round 2 decisions (session 2)
- K. Standard library round (session 2)
- L. Readability test round (session 2)
- M. Pre-test round decisions (session 4)
- N. Decisions forced by the type checker (session 4, M2)
- O. Runtime and agent tooling (session 4)
- P. Signature capabilities (session 4)
- Q. System-level commitments (session 4)
- R. Decisions from the first live readability round (session 5)
- S. Runtime dependencies and concurrency (session 6, M3)
- T. The MCP server (session 6)
- U. Readability round 2 (session 6)
- V. The gap audit and the road to self-hosting (session 6)
- W. The self-hosted front end (session 8)
- X. The speed of the VM (session 8)
- Y. The residue of stage 1 (session 8)
- Z. The bytecode file and the emitter (session 8)
- AA. The rename of
set(session 8) - AB. Constraints with type arguments (session 8)
- AC. Packages (session 8)
- AD. The diagnostics of the front end in Renyi (session 8)
- AE. The process module (session 8)
- AF. The foreign function interface (session 8)
- AG. Machine code for the bytecode (session 8)
- AH. The niche (session 8)
- AI. Release 0.1 (session 8)
- AJ. Foreign packages: Rust and Python (session 8)
- AK. The registration API (session 8)
- AL. The Python bridge (session 8)
- AM. The Python binder (session 8)
- AN. The resident world (session 8)
- AO. The watch of
serve(session 8) - AP. The embedding API (session 8)
- AQ. The profile-guided round on strings and JSON (session 9)
- AR. The baseline JIT (session 9)
- AS.
renyi build(session 9) - AT. The size of the generated code (session 9)
- AU. Static types to the code generator (session 9)
- AV. The icon and the wordmark (session 13)
- AW. The new backend (session 14)
- AX. The research track (session 15)
- AY. The amount budget (session 15)
Status: accepted. Date: 2026-10-05.
This record captures the first round of design decisions for Renyi. Each entry lists the question, the options that were on the table, the decision, and the reason. Decisions marked (user) were made explicitly by the language owner; decisions marked (derived) follow from those answers and the design reasoning recorded under them. The questions were asked in an interactive session; the original question list lives in git history (commit 231567e).
Later rounds append new entries rather than editing these. A decision is reversed by a new entry that names the one it supersedes.
0. Tensions and the trade-offs taken#
The requirements pull against each other in four places. These trade-offs were put to the owner and accepted.
| # | Tension | Decision |
|---|---|---|
| T1 | English-like syntax vs. token cost and LLM "plausible invention" | Regular English, not natural English. Fixed clause shapes, exactly one spelling per concept, no synonyms, one formatter output. (user) |
| T2 | Scripting convenience vs. Haskell-grade strictness | No dynamic escape hatch. Full type inference inside function bodies; mandatory signatures at the top level; errors carry fix suggestions so an agent self-corrects in one loop. (user) |
| T3 | Interop with other languages vs. strictness | FFI is first-class but boundary-validated. Foreign bindings read like ordinary functions and are generated from the host's own type information; every value crossing the boundary is validated at runtime and failures flow through the normal error channel. (user, revising the originally proposed "second-class but safe") |
| T4 | Runtime speed vs. compile speed vs. implementation effort | Compile/check speed > implementation effort > runtime speed. v1 is a bytecode VM; hot paths get AOT later. (user) |
A. Positioning#
A1. Script language, application language, or both. One toolchain, two
modes. renyi run file.ry type-checks and executes on the bytecode VM with
sub-30 ms startup. renyi build produces a self-contained executable (VM plus
bytecode). AOT compilation is a later milestone. (user)
A2. First real use cases. All four: agent workflows and API glue (including a sandbox for agents to run computations safely), data processing and cleaning scripts, backend services, and CLI / automation tools. The standard library and the capability model are prioritized in that order. (user)
A3. Primary author. LLM agents write, humans review. Consequences: errors are machine-parsable, the grammar forbids alternative spellings, documentation clauses are mandatory on public definitions, and the acceptance test for every syntax decision is "a human reviewer understands it at a glance". (user)
A4. Performance anchor. Lua-class interpreter for v1: bytecode VM, startup under 30 ms, several times faster than CPython on typical scripts. No AOT or JIT in v1. (user)
A5. First-class platforms. Linux, macOS and Windows command line; server-side WASI; browser WASM; embedding into host programs (Rust, Python, JS, C) through a stable C API. Mobile is out of scope. (user)
B. Types and strictness#
B1. Effects in the type system. Yes, fine-grained. A function declares the
capabilities it uses with a needs clause: needs network.http,
filesystem.read. Time and randomness are capabilities too, so a function with
no needs clause is pure and therefore replayable and trivially testable. The
checker requires every caller to declare a superset of its callees' effects.
Effects of function-typed parameters flow to the call site automatically, so
users never see effect variables. (user)
B2. Error handling. No exceptions. A function that can fail declares
or fails with ErrorType in its signature; the caller writes otherwise fail
to propagate, otherwise fail with NewError to translate, or otherwise
<default> to recover. Result and Maybe exist in the compiler but users
rarely spell them. The only ways a program terminates abnormally are an
explicit crash with "message" and arithmetic domain errors such as division
by zero. (user; the arithmetic exception is derived)
B3. Mutability. Immutable by default. let mutable name be value opens a
local mutable binding; set name to value updates it. Mutable state cannot be
shared across functions; the type system has no reference type. Imperative
for each loops stay in the language because LLMs write them more reliably
than folds. (user)
B4. Evaluation. Strict. A lazy keyword is reserved for opt-in laziness in
a later version. (user)
B5. Type system features in v1. Algebraic data types with exhaustive
pattern matching; generics spelled List of Item; abilities (type classes
without exposed higher-kinded types); refinement types and contracts spelled
Integer where value is at least 0. Higher-kinded types, GADTs and dependent
types are not implemented even internally. (user, who asked for the full set)
B5a. One unified type construct. The owner asked for "one universal, powerful type construct that greatly improves readability". Type theory needs only four constructors for data: product, sum, subset and constraint. Renyi spells them with one keyword and four clause words:
type User
has name: Text # product
has age: Integer where age is at least 0 # subset (refinement)
can Compare by age # ability (constraint)
end
type Shape is one of # sum
Circle(radius: Decimal)
Rectangle(width: Decimal, height: Decimal)
end
type Email is Text where value matches email_pattern # refined alias
The full design is in 02-syntax-sketch.md. (derived)
B5b. Type annotations. Every top-level function carries a full signature
(parameters, return type, failure type, effects). Inside function bodies
everything is inferred; let name: Type be ... is available when the author
wants to pin a type or guide generic inference. (user)
B6. Escape hatches. None. No any, no unsafe cast, no dynamic typing mode.
Unsafety lives only on the far side of the FFI boundary. (user)
B7. Null. Forbidden. An optional value has type maybe T; the absent value
is nothing; reading it requires otherwise or a match. (user)
B8. Object orientation. No classes, no inheritance. Data is records and
algebraic types; polymorphism is abilities. Dot syntax is kept for field access
(user.name) and for calling ability functions (shape.describe()). (user)
B9. Numbers. Integer is arbitrary precision. Decimal is exact decimal
arithmetic and is the type of literals like 19.99. Float is IEEE double and
must be chosen explicitly. There are no implicit numeric conversions. (user)
C. Syntax#
C1. Overall style: clause grammar. The owner asked for a merge of the "sentence" style and the "keyword" style, with a principled basis. The basis: syntax is a map from the abstract syntax tree to strings, and three properties make it good. It is injective and invertible (one spelling per program; the formatter is the inverse map). It has low conditional entropy (given the prefix, few continuations are legal, which is what makes an LLM's output reliable). It is homomorphic to the semantics (types are products, sums, subsets; error propagation is a monadic bind; collection queries are set comprehensions and monoid folds), so surface words map one-to-one onto those structures.
The resulting design is the clause grammar: every construct is a head
followed by labelled clauses. Clauses behave like record fields: optional,
with a canonical order the formatter enforces. Mathematical notation that is
universal stays (f(x), x: Type, + - * /); everything else is an English
word. A short signature sits on one line; a long one puts each clause on its
own line. Both are the same token sequence. (user accepted the merged design)
C1a. Three verbs replace =. let x be 5 defines, set x to 6 mutates,
x is 5 tests. The language has no = symbol. This removes the =/==
confusion class of bugs entirely; an LLM that writes = by reflex gets a
compile error with the fix. (user)
C2. Blocks. Explicit end. Indentation is never semantic. LLMs are not
robust to whitespace, RAG chunking and copy-paste destroy indentation, and
end makes every block self-delimiting. The formatter sets indentation to two
spaces. (user)
C3a. Equality. is and is not. Renyi has no object identity, so there is
no Python-style identity/equality confusion. (user)
C3b. Ordering comparisons: six phrases, no symbols. The owner suggested
deriving comparison words from is. One primitive, compare(a, b) returning
Less, Equal or Greater, is provided by the Compare ability; the six
phrases are the only spellings of relations:
| Spelling | Meaning |
|---|---|
a is b |
equal |
a is not b |
not equal |
a is less than b |
compare is Less |
a is at most b |
compare is not Greater |
a is greater than b |
compare is Greater |
a is at least b |
compare is not Less |
The phrase set is closed: larger, bigger, more than are not accepted.
Rule for symbols versus words: symbols are kept for operations that nest and
grow long (arithmetic), words are used for relations, which produce a Boolean
and do not nest. (user)
C3c. Remaining symbol table. Accepted as proposed: and, or, not;
+ - * / kept; remainder and power as infix words replacing % and **;
no pipeline operator (use let steps); # comments; "Hello {name}"
interpolation; List of T generics; maybe T optionals. (user)
C4. One spelling per concept. No synonyms. There is otherwise and no
else; function and no fn or def. Common misspellings from other
languages produce a compile error with the canonical form as the suggested
fix. (user)
C4a. Multi-word keywords are single lexical units. The owner asked whether
at least is one keyword or two, and whether to write at_least. Decision:
phrases such as is at least, or fails with, for each are single tokens
recognized by the lexer through a fixed phrase table with longest match (the
same technique SQL uses for ORDER BY and IS NOT NULL). No underscores: LLM
tokenizers split on whitespace anyway, embedding models align at least with
natural-language queries while at_least reads as an identifier, and the
source reads as English. Rules: the phrase table is fixed and printed in full
in the cheat sheet; only single spaces are allowed inside a phrase and no line
breaks; every word that appears in any code phrase is a reserved word; content
words used as keywords (count, sum, first, type, end) are reserved
too and the compiler suggests a descriptive rename, which is itself good for
retrieval; the one exception is a member name after a dot (event.type,
list.count), which may be any word because position disambiguates. Words
inside free-text documentation clauses are not reserved. (user)
C5. Enforcement. Naming rules (snake_case values and functions, PascalCase
types, abilities and variants) are compile errors with a rename suggestion.
Layout (one statement per line, no semicolons, line width, indentation) is
owned by renyi format, which has no configuration. (user)
C6. Identifiers. ASCII only: a-z, 0-9, _ for values, A-Z a-z 0-9
for types. Strings and comments accept any Unicode. (user)
C8a. Documentation is part of the grammar. Every public function, public
type and every module must carry a one-sentence purpose: clause; a missing
purpose is a compile error. Private helpers may omit it. (user)
C8b. Documentation clauses. purpose:, example: (an expression and its
expected value, executed by renyi test), tags: (free words, exported to the
index), see also: (references the compiler checks for existence),
deprecated: (see C8c). (user)
C8c. Deprecation is three-tiered. The owner asked whether deprecated
functions could be "skipped entirely". Skipping compilation would break every
existing caller at once, which defeats the purpose of a grace period, so the
decision is to skip discovery instead. A definition with a deprecated:
clause is (1) removed from renyi index, LSP completion, tool export and the
main documentation listing, so agents never pick it up for new code; (2) still
compiled for existing callers, with a warning that renyi check --strict
turns into an error, and an outright "delete me" hint once it has zero
callers; (3) automatically migratable: deprecated: since 2.0, replaced by
new_name lets renyi migrate rewrite call sites mechanically when the
replacement's signature is compatible. Removing a public definition bumps the
major version automatically (see G1). (derived, accepted)
C9. Anonymous functions. None. Every function has a name and, if public, a
purpose. The query form for each ... where ... collect covers map and filter;
sorted by field, group by field, sum, count, first, any, all
cover the remaining common higher-order uses; callbacks are passed as named
functions. (user)
D. Constraints that serve LLM readers and writers#
D1. Cheat-sheet token budget. The complete syntax cheat sheet must fit in 3000 tokens. It is measured in CI after every grammar change; exceeding the budget blocks the change until a feature is removed or compressed. (user)
D2. Cold start. The spec and cheat sheet travel in the prompt, the grammar skeleton stays close enough to mainstream languages for transfer, and the compiler's fix suggestions close the loop. A fine-tuning corpus is a later option, not a dependency. (user)
D3. Error output. Every diagnostic is emitted both as human-readable text
and as JSON (renyi check --json), with location, cause, and a suggested fix.
(user)
D4. Banned in v1. Operator overloading, macros and metaprogramming, implicit type conversions, wildcard imports, variable shadowing, single-letter identifiers, nesting deeper than four levels, and function bodies longer than about 60 lines. Each is a compile error. The depth and length limits exist so that every definition fits in one RAG chunk and one screen. (user)
D5. Operational definition of "retrievable code", plus content addressing.
Every definition carries a natural-language purpose; there are no wildcard
imports and no implicit context, so a chunk is understandable in isolation;
signatures and effect declarations are complete; there is no overloading and
no macro expansion, so the text is the semantics; renyi index emits one
record per definition with a stable identifier, signature, purpose, tags and
effects. In addition the owner chose content addressing: every definition
is identified by the hash of its canonical AST with dependency names replaced
by their hashes (the Unison model), so renames do not change identity, the
index deduplicates across copies, and the lockfile pins dependencies by hash.
v1 computes hashes in the toolchain; language semantics do not depend on them.
(user)
D6. Agent tools are first-class. An expose as tool clause on a function
publishes it as an agent-callable tool. Parameter types produce the JSON
Schema, purpose: produces the description, needs produces the permission
list. renyi tools lists them and renyi serve --mcp serves them. (user)
E. Runtime#
E1. Concurrency. Structured concurrency on green threads. run concurrently
... end runs the statements inside as parallel tasks and waits for all of
them; the first failure cancels the rest and propagates. for each ... in ...
concurrently collect ... is the parallel query. There is no async/await,
no bare thread, and shared mutable state is impossible by construction. (user)
E2. Memory. Tracing garbage collector. Ownership and lifetimes never appear in the surface language or in error messages. The VM may mutate in place when a value is uniquely referenced; this is invisible to users. (user)
E3. Sandbox. The runtime enforces declared capabilities. renyi run grants
exactly what the program's main declares and nothing more; --deny network
style flags narrow the grant further. (user)
F. Interoperability#
F0. FFI posture. First-class with boundary validation. Bindings are generated from C headers, Python type hints and TypeScript declarations, and read like Renyi functions. Return values are validated against the declared types when they cross the boundary; a mismatch fails through the ordinary error channel. (user, see T3)
F1. Compatibility scope for v1. Consuming JSON, HTTP, OpenAPI and databases (types generated from OpenAPI and JSON Schema); semantics close enough to Python and TypeScript that existing code translates mechanically; embedding Renyi as a scripting engine. Calling foreign libraries through FFI follows the posture in F0 but is scheduled after the v1 core (see H3). Transpiling Renyi to other languages is not planned. (user)
F2. "API friendly" priority. Calling external APIs first: HTTP and JSON are first-class, types are generated from OpenAPI. The language's own API (compiler as a library, AST as JSON, LSP) follows immediately at M5. (user)
F3. Host ecosystems. Python, Rust, JavaScript/TypeScript and C, all four. Implementation order: C ABI first because the other three build on it. (user)
G. Modules, packages, standard library#
G1. Versioning. Built-in package manager with a central registry and a lockfile. Semantic versions are decided by the compiler, Elm-style: removing or changing a public signature forces a major bump, adding one forces a minor bump. Combined with content addressing, a version number cannot lie. (user)
G2. Standard library. Small core (base types, collections, text, time) plus official extension packages (HTTP, JSON, filesystem, regex, CSV, SQLite) maintained in the same repository and released in lockstep. Imported on demand. (user)
G3. Files and modules. One file is one module and the module name equals
the path. The module header must match the path. .renyi and .ry are
fully equivalent. (user)
H. Implementation#
H1. Implementation language: Rust, one binary. The owner asked about Haskell for the compiler and why the runtime needs a language choice at all.
Why the runtime needs a systems language: the runtime is the bytecode interpreter, the garbage collector, the green-thread scheduler, the capability sandbox, the native parts of the standard library, the FFI bridge and the embedding C API. It runs underneath Renyi programs and cannot be written in Renyi, which by design has no manual memory management and no escape hatch. The platform decisions (30 ms startup, embedding, WASI and browser WASM as first-class targets) require a language without its own GC runtime, with a C ABI and mature WASM support: Rust, C or Zig. Rust is the only one with algebraic data types and pattern matching.
Why not Haskell for the compiler: it is entirely feasible (Elm and PureScript prove it) but costs two toolchains in one product, makes "compiler as a library" and embedding require linking the GHC runtime into Python, JS or Rust hosts, has an experimental WASM backend and painful Windows cross-compilation, and is not installed in the development sandbox while Rust 1.97 is. The parts of Haskell that matter (algebraic types, pattern matching, type classes, Option/Result) exist in Rust; the parts that do not (GC-backed AST sharing, laziness) are replaced by arenas and indices at roughly 1.3 to 1.5 times the code. Gleam, Roc and rustc are written this way. Haskell's heritage goes into Renyi's type system, not its implementation language. Self-hosting the compiler in Renyi is the long-term path. (user confirmed Rust)
H1b. Who writes it. Primarily Claude, in sessions. Work is sliced into units a session can finish; every unit ships with tests and a design note. The owner makes design decisions and reviews. (user)
H2. Order of work. Example corpus and cheat sheet first, then an LLM readability test (several models predict outputs and complete code from the cheat sheet; correctness rates are recorded), then the parser. The grammar is frozen by the readability test, not by the implementation. (user)
H3. First demonstrable milestone: M3. Parser, type checker and bytecode VM running the full example corpus. Milestones: M0 design documents and corpus; M1 lexer, parser, formatter; M2 type and effect checker with diagnostics; M3 bytecode VM; M4 standard library and package manager; M5 LSP, index, compiler API; M6 AOT and WASM targets; FFI generators follow M4. (user)
H4. License. Apache-2.0. (user)
H5. Documentation language. All English, including design discussion in this directory. (user)
H6. Testing from M1 on. A specification conformance suite (.ry inputs with
expected outputs, implementation-independent, reused for self-hosting); golden
tests for parse trees, formatter output and diagnostics; property tests
(formatter idempotence, parse/print round trip, type-checked programs never
crash the VM); and an LLM readability regression that reruns the model
prediction test and the cheat-sheet token count as a CI gate. (user)
I. Naming and clarifications#
I1. The name. "Renyi" is the owner's online handle. Spelling is fixed as
Renyi, no accent. The collision with "Rényi entropy" in search is handled by
documentation phrasing ("Renyi programming language", "Renyi lang") and does
not constrain the design. (user)
I2. "Keyword handling" means all four. Reserved words versus identifiers
(C4a), lexing of multi-word keywords (C4a), a cap on the total number of
keywords tied to the 3000-token cheat-sheet budget (D1), and searchable
keywords in code (C8b tags: and purpose:). (user)
I3. "Format optimization" means two things. Layout rules chosen for LLM tokenization efficiency and attention locality, not only for human aesthetics; and agent-friendly formats for everything the toolchain emits (diagnostics, index, documentation). (user)
I4. Influences. Adopted: Elm (diagnostics, compiler-enforced versions, no runtime exceptions), Gleam (small static type system without type classes' complexity), Roc and Koka (effects in types, platform/application split), Unison (content addressing, documentation as a first-class citizen). Explicitly avoided: Haskell's obscure surface (custom operators, point-free style, transformer stacks, extension maze) and Python's dynamism and significant indentation. (user)
J. Round 2 decisions (session 2)#
Round 2 settled the open items R2-1 to R2-17 of the syntax sketch. Each entry names the item it closes. The sketch was updated in the same commit.
J1. Named types are upward-only subtypes (R2-11). type X is Base makes
X a subtype of Base: an X is accepted wherever a Base is expected and
keeps its methods; a Base becomes an X only through construction, which is
fallible when X is refined. This is the one subtyping relation in the type
system. Rejected: fully distinct newtypes (every arithmetic step unwraps and
rewraps), plain aliases (no safety). (user)
J2. Map literals use JSON braces (R2-1). {"a": 1, "b": 2} and {}. The
notation is universal and matches the data the programs consume; a word form
would be long and error-prone. (user)
J3. Documentation clause words are reserved (R2-2). purpose, tags,
example, see, also, deprecated stay in the reserved list. One word,
one role; the compiler suggests renames (tags to labels). (user)
J4. No contracts on parameters (R2-13). Constraints live on named types
(type Attempts is Integer where value is at least 1) and are checked at
construction. Parameter signatures stay plain and call sites do not sprout
otherwise. (user)
J5. Interpolation everywhere, plus raw (R2-14). Every "..." and
"""...""" literal interpolates {expression}; a literal brace is \{; a
hole may not contain a string literal. raw "..." is a literal with no holes
and no escapes, for regular expressions and for JSON or SQL samples. One new
reserved word. Rejected: \{ alone (regular expressions become unreadable),
opt-in interpolation (the common case gets longer and the prefix gets
forgotten). (user)
J6. if and match are expressions (R2-12). Allowed where a value is
expected when every branch is a single expression or a way out (fail,
fail with, return, crash with); an if expression needs otherwise.
Six of the thirty corpus programs use the form where other languages use a
ternary operator. (user)
J7. No list patterns in v1 (R2-3). is_empty(), first() and rest()
cover the corpus. Revisit after the readability test if recursion over lists
turns out to be common. (user)
J8. Bare variant patterns; unused bindings are errors (R2-16).
when Circle then matches a variant without binding its fields. Any binding
that is never read, whether from let, a loop header, a parameter or a
pattern, is a compile error with the fix "remove it". Patterns therefore name
exactly what the branch uses, and no wildcard is needed. (user)
J9. / needs Decimal or Float operands (R2-4). Dividing two Integers is a
compile error that points to a.quotient(b) (integer division) or
a.to_decimal() / b. No operation changes the type of its operands. The
corpus never divided two Integers, so the rule costs nothing. Supersedes the
sketch's earlier "Integer / Integer yields Decimal". (user)
J10. No default method bodies in v1 (R2-5). Every implementation block spells out every method, so a retrieved implementation is complete on its own. Revisit if the corpus shows repeated identical implementations. (user)
J11. Scoped capabilities are in v1 (R2-6). A capability may carry one
literal argument naming its scope: a path prefix for filesystem and its
children, a host for network and its children, a variable name for
environment, a program name for process. A declaration without an
argument covers every scope. The checker requires each caller to cover its
callees: the same or an ancestor capability, with no argument or with one
that contains the callee's. At run time a primitive compares the actual path
or host with the calling function's declared scope and reports a mismatch
through its ordinary error type (PermissionDenied(path),
HostNotAllowed(host)). renyi run can narrow scopes further from the
command line. Claude recommended deferring this to keep the checker simple;
the owner chose precision in the source. (user)
J12. Deadlines on concurrency with within (R2-7). run concurrently
within duration and for each ... concurrently within duration ... cancel
the remaining tasks when the duration expires and fail with the built-in
TimedOut, which the enclosing function lists in or fails with. Durations
come from std.time (time.seconds(5)). One new reserved word. (user)
J13. No positional exception for commutative functions (R2-8). Two or
more arguments are always named. The standard library expresses the common
cases as single-argument methods: width.at_least(minimum),
width.at_most(limit), items.largest(), items.smallest(). (user)
J14. External field names with as (R2-9). has kind: Text as "type"
gives a field the name that ToJson, FromJson and FromRow use; it is the
only way to map keys that are reserved words or contain punctuation. A
convention-wide mapping is a decoder option:
json.parse(text: text, naming: CamelCase). as is already reserved. (user)
J15. Unused results are errors; ignore discards (R2-15). A call whose
non-empty result is not used is a compile error whose message proposes the
likely fix (set items to items.append(item)). ignore expression discards
a result on purpose. One new reserved word. (user)
J16. Decimal is IEEE 754 decimal128 (R2-17). 34 significant digits;
literals, sums and products of everyday values are exact; division rounds
half-even at the 34th digit; overflow crashes like any arithmetic domain
error. Float is IEEE 754 binary64. Rejected: exact rationals (unbounded
denominators, and printing needs a rounding rule anyway), fixed scale
(truncates rates and scientific values). (user)
J17. Single-file module names (R2-10). A .ry file run outside a project
is the module named after its file stem, and its header must say so. The
rule "module name equals path" holds with the file's directory as the project
root. (derived)
J18. Reserved words after round 2: 84. ignore, raw and within join
the 81 words of C4a. The phrase table is unchanged. (derived)
K. Standard library round (session 2)#
Asked while writing 04-stdlib-sketch.md; answers shape every module.
K1. Methods are functions with self: Type (S1). A function whose first
parameter is self: T is a method of T, called value.name(...), and must
be declared in the module that defines T. Base-type methods (text.trim())
and standard-library methods (connection.query(...)) follow this one rule;
abilities exist for polymorphism, not for attaching methods. Rejected: one
single-implementation ability per type (ceremony, longer retrieval results),
module functions only (no chaining). (user)
K2. Non-2xx HTTP statuses are failures (S2). http.get(url) otherwise fail
leaves a 2xx response on the success path; other statuses fail with
HttpError.Status(url, status, body). The classic forgotten status check
cannot happen; a program that expects a 404 matches the failure. (user)
K3. matches in the prelude, the rest in std.regex (S3).
text.matches(pattern) needs no import, so refined text types stay short;
capture groups, find-all, replace and split live in std.regex on a Pattern
type. The engine is in the runtime; literal patterns are checked at compile
time. (user)
K4. Minimal Bytes in v1 (S4). Bytes is a prelude type with length,
is_empty, to_text (fallible UTF-8 decode) and to_base64;
text.to_bytes(), filesystem.read_bytes, filesystem.write_bytes, and
Response.bytes use it. (user)
K5. json.parse_with clarifies J14. There is no overloading and there are
no default arguments, so the convention-mapping decoder is a separate
function: json.parse_with(text:, naming:), json.render_with(value:,
naming:). (derived)
K6. Record patterns. A record type is matched like a single variant:
when InvalidDate(input) then. Error types such as InvalidDate and GaveUp
are records, so match and example: ... fails with ... need this. (derived)
K7. Self in ability declarations. Inside an ability declaration Self
names the implementing type, for binary methods such as compare(self, other:
Self). It is a predefined type name like Integer, not a reserved word.
(derived)
K8. Pairs. Pair of Left, Right is a prelude record with fields left and
right. A two-variable loop or query header destructures a pair;
map.entries() and items.with_index() return lists of pairs, and iterating
a map yields its entries. (derived)
K9. Maps and sets keep insertion order (R3-1). Iteration, keys(),
values() and entries() follow insertion order, so output is deterministic
and examples can compare whole maps. Python and JavaScript behave the same
way, which is what generated code assumes. (user)
K10. Variants encode as a flat object with a kind key (R3-2).
Circle(radius: 2.5) is {"kind": "Circle", "radius": 2.5} and Point is
{"kind": "Point"}; a variant with a field named kind is a compile error
when the type derives ToJson or FromJson. This is the discriminated-union
shape most APIs use. Supersedes the externally tagged draft in the first
version of the library sketch. (user)
K11. console.print takes only Text (R3-3). Other values are printed
through interpolation, console.print("{total}"). No generic entry point
converts to text implicitly. (user)
K12. Float renders with a decimal point. Float.to_text() is the shortest
text that reads back as the same value and always contains a decimal point
(5.0), so a Float is never mistaken for an Integer in output. Decimal
keeps the digits of its exponent instead (6.00 after rounded(2)).
(derived)
L. Readability test round (session 2)#
L1. Models and credentials. The first live round uses Anthropic and OpenAI
models, at least three in total including the smallest model the project
intends to support (claude-haiku-4-5). Credentials are environment variables
of the cloud environment (ANTHROPIC_API_KEY, OPENAI_API_KEY), never part of
the repository or the conversation. (user)
L2. Who judges Complete and Write before M3. Claude judges each lint-clean
sample in the session and records the verdict with a one-sentence reason in
judgement.json; the owner spot-checks. The judge shares its origin with some
of the tested models, so every verdict is re-run by the VM at M3 and the two
sets of results are compared. (user)
M. Pre-test round decisions (session 4)#
The readability pre-test (tests/readability/2026-10-05-e41258c/notes.md)
raised these questions; the owner answered them in one batch.
M1. group by combines with every terminal clause. for each sale in
sales group by sale.region sum sale.amount is a Map of Text to Decimal:
the terminal after group by is applied to each group, so collect, sum,
count, first, any and all all work per group, and a bare group by
keeps whole items as before. Both models of the pre-test wrote this form for
the same program and the parser already accepted it. (user)
M2. The loop variable of a bare count query is unused. In for each
line in order.lines count the variable line is never read, so decision J8
applies and the fix is order.lines.length(); one concept keeps one spelling.
The variable of a first query counts as read because first returns it.
(user)
M3. otherwise on a value that cannot fail is an error. otherwise is
allowed only after a maybe value or a fallible call. Port(8080) otherwise
crash with ... (a literal checked at compile time) and line.split(" ")
otherwise fail are compile errors whose fix is "remove otherwise: this
cannot fail". (user)
M4. A named single argument is an error. column_widths(table: table)
is rejected with the fix "drop the name": one argument is positional, two or
more are named, and the formatter never changes tokens. The same holds for a
construction with one field (UserId(id: 7)). (user)
M5. The readability scoring formats before it lints. renyi format runs
on every Complete and Write program before the lint, since an agent runs the
formatter anyway; layout violations are still counted and reported per rule
but no longer fail a sample. 03-readability-test.md is updated. (user)
M6. The cheat sheet gains a library section. Names only (prelude text, list, map and set methods; the standard modules), within the 3000-token budget. Invented library names were the largest cause of Sonnet failures. (user)
M7. Haiku 4.5 stays the floor model (L1). Its pre-test rates (Complete 37%, Write 0%) are from one sample per item; the cheat sheet is iterated on the failure causes first, and the live round with five samples decides. (user)
M8. An MCP server for the toolchain, after M2. A server that offers the
cheat sheet, a library-name lookup, check and format (later run and
test) to any agent host is scheduled after the type checker, when check
has substance; whether it reuses the renyi serve --mcp command of decision
D6 or gets its own subcommand, and whether a JSON dependency is taken, is
decided then. (user)
M9. repeat until replaces while. The only condition loop is
repeat until condition ... end: the condition is tested before each pass
and names the state that holds when the loop is over, so the reader gets the
postcondition without negating anything (repeat until remaining.is_empty()
instead of while not remaining.is_empty()). repeat until is one phrase
token; repeat and until are reserved and while leaves the list, which
has 85 words (supersedes the count in J18). while becomes a foreign
keyword: the compiler rejects it and suggests repeat until with the
opposite condition. The owner asked for a simpler, fixed loop shape;
for each is unchanged. (user)
M10. No bottom-tested loop. The "do, then test" case (pagination) keeps
its flag variable or uses break; the corpus has one such loop. Revisit after
the live readability round. (user)
N. Decisions forced by the type checker (session 4, M2)#
Derived while turning the library sketch into declaration files the compiler
reads (library/std/*.ry) and writing the checker; each follows from an
earlier decision and is recorded so that it can be questioned.
N1. A method may be named with a reserved word. The library declares
first, at, set, sum, sorted and repeat as methods, and the
corpus calls them after a dot, where any word is allowed (C4a). A function
whose first parameter is self is only ever called after a dot, so the
parser accepts any word as its name; an ordinary function keeps the rule.
Parameters are bound as plain names and keep the rule too, so the library's
count parameters became length, days and amount. (derived)
N2. Path, Url and Pattern are plain subtypes of Text. Their
validity is checked by the operations that use them (a missing or malformed
path fails with FileError, a malformed URL with Unreachable) and, for
literals, at compile time by the toolchain. Constructing them from runtime
text therefore needs no otherwise, which is how the corpus already writes
Url("{base}?{query}") and Path(path_text); the sketch's where value is
not "" on Path is dropped. (derived)
N3. Library error types derive ToText. The corpus logs errors with
error.to_text() in failure arms, and the cheat sheet shows the same, so
every error type the library declares carries can ToText; a program's own
error type adds the clause when it is rendered. ToText stays opt-in for
other types. (derived)
O. Runtime and agent tooling (session 4)#
Asked by the owner as three questions (how memory is managed, what sets the
language apart, what the language can offer LLM agents); the owner took the
recommendations as given. The design is in 05-agent-tooling.md.
O1. Memory is reference counting with in-place reuse; supersedes E2.
Renyi's values are immutable, there are no references, no closures (a
function is passed by name and captures nothing), and no shared mutable
state, so the value graph is acyclic: a value cannot contain itself.
Acyclic data needs no tracing collector. The VM counts references, frees a
value when its count reaches zero (so a file or a connection closes as soon
as it is dropped, deterministically), and updates a value in place when its
count is one, which makes set items to items.append(item) an O(1) append
when nothing else holds the list (the Perceus/Koka and Roc model; the
compiler marks last uses so that arguments are moved, not copied). The v1
scheduler runs green threads on one OS thread, so counts are not atomic;
when tasks move to several threads, values that cross a task boundary get
atomic counts. The user-facing promise of E2 stands unchanged: ownership
and lifetimes never appear in the language or in a diagnostic. A future
lazy must keep the graph acyclic (a thunk may not refer to its own
binding). (user, on Claude's recommendation)
O2. The project map is the agent's view of a project. renyi index
(decision D5) emits one record per definition and one per module, as JSON:
identity (content hash), kind, signature, purpose, tags, declared and
transitive effects, declared and transitive failure types, the edges
(calls, type uses, implementations, tests), six metrics (lines, nesting
depth, branch points, effects, fan-in and fan-out, example and test
coverage) and the source location. Every number is exact because the
language has no macros, no overloading and no dynamic dispatch outside
abilities. The map is incremental by hash and is what an agent reads
instead of files; granularity is module to definition, with tests as nodes
of their own. (user)
O3. Complexity budgets. The per-definition limits of D4 (nesting depth 4, about 60 lines) stay compile errors. Module-level budgets (public definitions per module, size of the transitive effect set, fan-out) are reported by the map and gated in CI as warnings first; thresholds are set once the map has been measured on the corpus (open item R5-1). (user)
O4. Effect and semantic diffs. renyi index --diff compares two maps
and reports changed signatures, effects and failure types with the callers
each change reaches; the version-bump rule of G1 reads the same diff, and
an agent checks that its change did not widen any grant. Scheduled after
M3. (user)
O5. The toolchain MCP server is renyi mcp. Decision M8's server gets
its own subcommand, distinct from renyi serve --mcp (D6), which serves a
program's own expose as tool functions. renyi mcp speaks JSON-RPC over
stdio and offers project_map, definition, effects, check,
format, cheat_sheet, library_lookup, and after M3 run, run_tests
and diff. The checker's World stays resident and is refreshed by
content hash. serde_json is taken as a dependency: the zero-dependency
rule ended when regex entered the checker, and a hand-written parser
would buy nothing. (derived)
P. Signature capabilities (session 4)#
The owner asked for at least one capability no other language has had, new,
practical and elegant, and chose three of the four candidates. Each rests on
the effect system: every effect goes through a declared capability and a
small set of library primitives, so the runtime sees all of them. Design:
06-runtime-guarantees.md.
P1. Recorded runs. renyi record program.ry runs a program under its
grant and writes every effect call (capability, primitive, arguments, result
or failure, clock and random values) to a recording. A test declared with
replays "path" answers its effects from the recording, deterministically
and offline; a call the recording lacks fails the test. renyi run --replay
re-executes a recorded run for debugging, and --explain narrates any run
with the purpose: clauses of the definitions it passes through, the data
they produced and the effects they used (the self-narrating layer). The
effect system guarantees the recording is complete; the ToJson rules give
it a readable format that the replay validates against the declared types.
One new reserved word, replays. Nearest prior art: VCR-style HTTP
recording libraries and Darklang's trace-driven development, neither a
language feature with a completeness guarantee. Scheduled in M3. (user)
P2. Budgets in grants. A capability in the grant of main or of a
test may carry at most COUNT per UNIT (units second, minute, hour,
day, run); the runtime counts primitive calls under it and fails the
call that exceeds the budget with the module's error type. Budgets apply to
network, process and filesystem. One new reserved word, per, and
the phrase at most. Scheduled in M3. (user)
P3. Provenance guards. A capability in the grant may carry only to
SINK or SINK: values that enter through it, and values computed from them,
carry that origin and may leave the program only through the listed sinks;
any other outgoing primitive fails with Guarded(origin, sink). This is the
language-level answer to exfiltration through prompt injection, the central
risk of agent sandboxes. The runtime tracks origins as a small set per heap
value, which Renyi's immutable values and explicit effects make cheap.
One new reserved word, only, and the phrase only to. The syntax is in
the grammar now so that the cheat sheet, the parser and the live
readability round see it; the runtime part is designed first and scheduled
in M4. Prior art: information-flow languages (Jif, FlowCaml, LIO) and
runtime taint modes (Perl, Ruby); none ties the policy to the capability
grant. (user)
P4. Reserved words after P1 to P3: 88, phrases 17. only, per,
replays join the list (supersedes the count in M9); at most and only
to join the phrase table. Budget units are plain words after per, not
reserved. (derived)
Q. System-level commitments (session 4)#
The owner asked for system-level innovations that solve pain points of
mainstream languages outright and resolve their "cannot have both"
trade-offs; all four candidates were taken. Design: 07-system-design.md,
whose section 1 states the trade-offs the language claims to resolve.
Q1. Capability-safe packages. A package's effect manifest is computed
by the toolchain at publish and recomputed by the registry; main's grant
must cover the transitive effects of every dependency the program reaches,
with the package and capability named in the error; an update whose
effects widen is refused unless the grant covers them and the user accepts;
scopes narrow dynamically across package boundaries through the grant
stack (the effective grant is the intersection along the call chain, which
every primitive checks); native code is visible as foreign. Supersedes
the wording of J11 for cross-package calls; within a program the static
coverage rule stands. M3 (grant stack), M4 (packages). (user)
Q2. Reproducibility by construction. A run manifest names everything a
run depends on (toolchain, code and dependency hashes, grant, arguments,
environment variables read, recording); renyi reproduce replays it and
compares byte for byte; builds are functions of the same hashes. Rests on
P1, K9 and D5. M3 and M4. (user)
Q3. In-process sandboxing. The effect grant is the isolation boundary: a host loads a module with a grant (capabilities, scopes, budgets, guards, a memory budget) and the module can reach nothing else, with no process or container; several modules with different grants share one process through the grant stack on the task tree. After Q1; embedding API at M5. (user)
Q4. Checked live update. A running service swaps the changed definitions of a type-checked new version between requests, by content hash, after the semantic diff shows no public signature a running definition calls has changed; there is no state to migrate because the language has no hidden mutable state. M5. (user)
R. Decisions from the first live readability round (session 5)#
The round (tests/readability/2026-10-05-1623155/, its notes.md) ran
Sonnet 5.5, Haiku 4.5 and gpt-5.4-mini with five samples per prompt. By the
four-of-five rule: Sonnet Predict 90, Explain 97, Complete 79, Write 40;
Haiku 30, 90, 37, 0; gpt 80, 97, 32, 0. Each measured cost below was put to
the owner as a question with the recommendation first.
R1. The freeze is gated on the large models. The acceptance thresholds
of 03-readability-test.md apply to the current large model of each vendor
(Sonnet 5.5 and its successors, gpt-5.5 from the next round); the floor
model of M7 (Haiku 4.5) is run and reported as a trend and does not gate
the freeze. Haiku failed Predict at 30 percent through arithmetic and
attention errors (mis-added means, dropped parentheses, wrong column
widths), none of them a grammar misreading, so "every model" would never
freeze the grammar. Supersedes the wording "on every model" of the
protocol; M7 stands. (user)
R2. J3 stands: reserved words are reserved everywhere. The query words
(count, sorted, first, sum, ...) stay reserved outside queries too.
Measured cost: Sonnet loses two Complete items to count as a local name
(79 percent against 89 without the rule); Haiku and gpt lose more to
sorted and first. One word, one role, is worth it. (user)
R3. purpose: stays required on public types and on the module. It is
the largest single Write rule (28 percent of Sonnet's violations, over the
protocol's quarter; 25 percent of gpt's). The rule is kept because the
project map (O2) reads those purposes; the cheat sheet states it in one
explicit sentence and every public type in its examples carries one, since
the readers copy the examples. (user)
R4. M4 stands: a named single argument is an error. It is the largest checker rule for Haiku (92 samples) and gpt (77). The uniformity (one argument positional, two or more named) is kept over the pass rate. (user)
R5. is on numbers. Both operands must have one type: an Integer and
a Decimal do not compare (no implicit conversion, as the cheat sheet
says). A numeric literal takes the numeric type its context expects (an
Integer literal fits Decimal and Float, a Decimal literal fits Float),
so total is 0 with total: Decimal compares two Decimals. Two Decimals
compare by numeric value; the scale is not significant: 32.0 is 32.00 is
true, and so is 0.00 is 0 through the literal rule. This is what the
judges of the round, the checker's refinement evaluation and IEEE
decimal128 comparison already do. (user; the value reading derived from
J16)
R6. ignore discards only the result of a call with effects. Supersedes
the wording of J15: ignore call is allowed when the call needs a
capability (the callee's needs, or those of a function passed to it);
discarding the result of a pure call is a compile error, ignore-pure,
whose fix proposes set x to x.method(...) for a method on a mutable
binding and otherwise "bind the result with let, or remove the call".
Three judged samples of the round wrote ignore pop(stack) on an immutable
value and so never shrank the stack; under this rule the checker catches
it. The error for a call returning nothing (ignore-nothing) stays. (user)
R7. Budget thresholds (R5-1). The first defaults of renyi index
--budgets are 10 public definitions per module, 5 transitive effect paths
per module and fan-out 7 per definition, each just above the corpus
maximum; a value over budget is reported, never a compile error (O3). The
thresholds move to the project manifest with the package manager (M4).
(user)
R8. A fourth model from the next round. gpt-5.5 rejects temperature 0
and was not run; it joins the next round at its default temperature, as
Sonnet 5.5 ran in this one, so that each vendor has a large model gating
the freeze (R1). (user)
S. Runtime dependencies and concurrency (session 6, M3)#
Each question was put to the owner with the recommendation first, after a probe crate had built the candidates on the owner's machine (GNU toolchain, 31 seconds, all three working).
S1. Three dependencies for the runtime. The HTTP client of std.http
is the ureq crate (version 3, rustls with the ring provider: no system
TLS, no C code for the client); std.sqlite is rusqlite with its
bundled feature (the SQLite sources compiled into the binary, which needs
a C compiler on the build machine); std.server is written over
std::net::TcpListener (HTTP/1.1, one request at a time, no TLS, which a
local service or one behind a proxy does not need). Redirects are followed
by the runtime one hop at a time so that every host a request reaches is
checked against the grant. Alternatives declined: a hand-written client
(no TLS, so the corpus could only run from recordings), reqwest (tokio),
tiny_http, and leaving any of the three unbuilt. (user)
S2. Tasks run one after the other. run concurrently and
concurrently queries execute their tasks in source order on one thread,
with the within deadline checked between statements and items. The
meaning of a program is unchanged: tasks are independent, so their order is
unobservable except through time, and values stay single-threaded
reference counts (O1). Overlapping I/O waits (green threads on one OS
thread) is a later runtime improvement, not a language change; a thread
per task was declined because values would have to cross threads. (user)
S3. Redaction by name. renyi record --redact NAME (also renyi test
--refresh) replaces, in the recording, the value of an argument named
NAME, of an entry named NAME (ignoring case) inside a map argument such as
a header list, and of the environment variable NAME as environment.get
returns it, with the placeholder <redacted>; a replay matches the
placeholder against any value, so a recording made with a real key replays
with any key. Redaction is by name, not by data flow: a secret that
reaches another argument is recorded as it is (provenance guards, P3, are
the data-flow mechanism). Settles open item R6-3. (user)
S4. Response bodies stay inline. A recorded HTTP response keeps both
its text (body) and its bytes (bytes, base64) in the recording, with
no size limit and no side file; the corpus fixtures are small, and a
side-file format can be added when a recording needs one. Settles open
item R6-1. (user)
S5. The run manifest lives in the recording. renyi record writes
the manifest of decision Q2 into the header of the recording it makes:
the toolchain, the source path, the content hash of main (which covers
everything main reaches), the arguments, the environment variables read
with the hash of each value or the redaction placeholder, the outcome, and
the SHA-256 and length of the standard output. renyi run --manifest
prints the same header and writes no file. renyi reproduce FILE
[program] refuses when main hashes differently, warns when the
toolchain differs, replays with the console output written, and reports a
different outcome or output and any recorded call not reached. The owner
asked whether the manifest could live in the .ry file itself; declined
because a manifest describes one run of a program rather than the program,
every record would rewrite the source, and the grammar under measurement
would grow. A separate manifest file was declined to keep one file per
run. Until the registry (M4) the code is read from the path the manifest
names and checked by hash. (user)
S6. No narration of query clauses. --explain narrates a function's
entry with its arguments, its result, and each effect; a query inside it
(for each ... where ... collect) is not narrated as a sentence of its
own, since the function's result shows what the query produced and a line
per query would lengthen the trace. Settles open item R6-2. (user)
S7. A budget is a number. at most COUNT per UNIT takes a literal
count, not a constant: the budget sits in the signature of main or of a
test so that the reviewer reads the number there. Settles open item R6-4.
(user)
T. The MCP server (session 6)#
renyi mcp (decision O5) was built after M3; each question was put to the
owner with the recommendation first.
T1. Both eras of the protocol. The current revision of the Model
Context Protocol (2026-07-28) has no handshake: every request names its
version and the client's capabilities in _meta, and the server must
answer server/discover; the hosts in use today still open with the
initialize handshake of revision 2025-11-25 and earlier. renyi mcp
speaks both, as the specification's compatibility section allows a
"dual-era" server to: a request with a version in its _meta is answered
statelessly as the current revision says, and an initialize request
selects the handshake. Supporting only the handshake would leave the
server behind the specification; supporting only the current revision
would leave every host on this machine unable to connect. (user)
T2. The VM's JSON reader serves the protocol. Decision O5 took
serde_json as a dependency for the server; since then the VM has its own
JSON reader and writer (std.json, the recordings of decision S4), which
the server uses instead, so the toolchain keeps one JSON implementation
and no new dependency. Supersedes that sentence of O5; the rest of O5
stands. (user)
T3. run and run_tests take what the command line takes. Besides
the path and the arguments of section 7's table, the run tool accepts
the narrowing options of renyi run (deny, allow_host, allow_read,
allow_write, at_most), a replay recording and explain, and
run_tests accepts strict and explain, so that an agent can sandbox
or replay what it runs exactly as a person can. (user)
T4. The map is refreshed by file, not by definition. Section 7 of
05-agent-tooling.md said the server refreshes only the definitions whose
content hash changed; the server rebuilds the whole map when any file of
the served directory differs from the one the last map was built from.
The result is the same, and the corpus (30 modules) rebuilds in about a
second in a debug build; the per-definition refresh is open item R5-5,
for projects large enough to need it. (user)
T5. The diff reads a definition's own text hash beside its content
hash. Section 6 of 05-agent-tooling.md reported a body change from the
content hash; the content hash of decision D5 also changes when anything
the definition depends on changes, so a one-line change in a helper would
read as a body change in every caller, and the origin of a change would be
lost. Each record now also carries text_hash, the hash of the
definition's own canonical text with its own name and every reference to a
project definition blanked (the first two edits of D5, the references
blanked rather than replaced by hashes, and without the dependency and
library material). The diff reports a body change where text_hash or the
edges changed and lists the callers under what the change reaches; a
definition is matched across the maps by its qualified name, and a name
gone whose content hash is back under another name is one rename entry,
its callers untouched, as D5 intended. A map written before this field
falls back to the content hash. The base of a diff is a map file or a git
revision; a revision's files are read with git show and indexed afresh
with the same toolchain, so that the diff never needs a map to have been
saved. The version bump of G1 is derived from the entries: a public
definition removed, its signature changed (the needs and or fails with
clauses included), made private or renamed is a major bump; one added or
made public a minor bump. (derived)
U. Readability round 2 (session 6)#
Round 2 (tests/readability/2026-10-05-ed37120/notes.md) raised four
questions; each was put to the owner with the recommendation first.
U1. M4 stands; the cheat sheet says it in a sentence. "A call with one
argument does not name it" (decision M4) was again the largest checker rule
for all four models of the round (43, 50, 90 and 68 error lines for Sonnet
5.5, gpt-5.5, Haiku 4.5 and gpt-5.4-mini) and cost gpt-5.5 the Write item
fizz_words outright. The recommendation was to let a single argument be
named or not; the owner keeps the rule, as after round 1, and the cheat
sheet states it in a sentence beside the call examples ("One argument is
never named: web.get(url), not web.get(url: url)") instead of a comment.
Measured again in the next round. (user)
U2. rounded keeps its places; the cheat sheet shows the call. Both
gating models wrote value.rounded() and decimal.to_decimal() and lost
invoice and shapes (Complete) and compound_interest (Write) to it;
gpt-5.5 would pass Complete without those two items. The recommendation
was a library change (places defaulting to 0, to_decimal an identity on
Decimal); the owner keeps the library as it is and has the cheat sheet
list the method as rounded(places: 2), so that the argument is seen
before it is needed. (user)
U3. Every method call takes parentheses; the cheat sheet lists methods
so. The models wrote text.length, items.is_empty and items.last as
fields (21, 100 and 20 error lines for gpt-5.5, Haiku and gpt-5.4-mini)
because the library section of the cheat sheet listed the method names
bare. The owner asked whether a form without parentheses should be spelled
length of items; that would be a second spelling of one call, against
the one-spelling rule of the cheat sheet's first line, and no model had
written it, so the grammar is unchanged and the cheat sheet lists every
library method with its parentheses (length(), is_empty(), ...). (user)
U4. Explain is graded by Claude Code subagents; round 1 is re-graded the
same way. Round 2 graded Explain with subagents (Sonnet 5.5 first, Opus
5.5 second, fifty samples a batch, a reason kept with every grade) because
the owner ruled during the round that the pay-per-token API keys of
decision L1 are not spent by default and subscription quota is used
instead. Measured against the API grades collected before the ruling, the
subagents are about one point more lenient and flip 30 of 204 floor-model
samples from fail to pass, none the other way. The protocol needs one
grader kind across rounds, so the subagents grade Explain from here on,
round 1 is re-graded with them so that the series is on one scale (its
API-graded tally is kept beside the new one), and the API graders are used
only when the owner authorizes the keys for a round. The harness now
snapshots the references into each run directory at prepare, after a
description went stale between the rounds. L1's credentials sentence
stands for the API path; this entry adds the default. (user)
U5. A hand verdict extends to every sample that repeats the sentence it
called wrong. The re-grade of round 1 (U4) showed the subagent graders
agreeing on a passing grade for three statements the hand verdicts call
wrong (Sonnet's retry.3, Haiku's inventory_db.2 and
shipping_rules.0), and the adjudication rule of the protocol reaches
only samples the two graders disagree on by more than one point. From
here a hand verdict of 2 on a sentence applies to every sample, of any
model in any round, that repeats the sentence or makes the same statement
about the same program; the adjudicator searches the program's samples
for it and records a verdict that names the originating one. Applied to
both rounds in session 6, fourteen verdicts: in round 1 Haiku's
inventory_db.1 to .4, shipping_rules.0, invoice.2 and .4 (where
a session 5 verdict of 4 had read "quantities and prices are
non-negative" as correct and is withdrawn, the quantity being at least
1), Sonnet's shipping_rules.1 and retry.3; in round 2 Haiku's
inventory_db.0 to .4 ("items that have fallen below their reorder
threshold" for at or below). Haiku's Explain is 27 of 30 in round 1 and
26 of 30 in round 2 after it; no gating model's item moved. The
alternatives were to keep the rule (the floor model's number then
carries grades the hand would not give) and a hand pass over every
agreed grade (1050 samples, declined as not worth it while the gating
models are unaffected). (user)
U6. The five-point rule applies to the gating models. The protocol's
rule that a grammar change lowering any passing rate by more than five
points is reverted or explained did not exempt the floor model, and
Haiku 4.5's Explain fell between the rounds on the one scale (97 to 90
before U5, 90 to 87 after it) on wrong statements about todo_cli,
invoice and inventory_db, not on any changed rule. The floor model is
reported as a trend and does not gate (R1), and its reading errors would
trigger the rule every round. The rule now names the gating models; the
floor model's moves are reported and explained in the round's notes.
03-readability-test.md amended. (user)
U7. Round 3's samples come through the subscription channels. The
default of U4 (no pay-per-token keys unless the owner says so for the
round) applies to collecting samples too: the Claude models are sampled
by Claude Code subagents and the OpenAI models by the Codex CLI on the
ChatGPT subscription, each sample fed to the harness with run --provider
file (round 2's gpt-5.5 Write samples came that way). The cost is
comparability: a subagent cannot be sampled at temperature 0 and sees the
host's system prompt around the cheat sheet, so the floor model's rates
carry more noise than in rounds 1 and 2; the gating models already ran at
their default temperature. The owner may still authorize the keys for a
round, and then the API path of run is used as in rounds 1 and 2.
03-readability-test.md amended. (user)
U8. The library list carries parameter names; a sentence beside it gives
the call form. Round 3 (tests/readability/2026-10-06-3e7c45a/notes.md,
Sonnet 5.5 through the Claude Code CLI) measured the cheat sheet after U1
to U3 and found the rendering of U2 and U3 wrong: the list showed
rounded(places: 2), a single argument named, which decision M4 forbids
in a call, and split() beside length(), which hides the separator.
Sonnet copied both as shown: rounded(places: 2) in every sample of
invoice and shapes (Complete) and compound_interest (Write), all
rejected by the checker ("a call with one argument does not name it"),
and split() in three of five word_count samples ("split takes 1
argument (separator), found 0"); its Complete fell from 89 to 68, with
shapes and word_count lost to the rendering and deadlines and
invoice_report to the reserved word count. The rendering was
Claude's reading of U2 and U3, not what they decide (the argument seen
before it is needed; every method a call): both stand, in this form. The
list now gives every method with its parameter names (split(separator),
rounded(places), replace(old, new), set(key, value)), checked
against library/std/prelude.ry, and one sentence after it gives the
call form of M4: line.split(","), price.rounded(2),
text.replace(old: "a", new: "b"). Paid for by shortening the
phrase-token list to three examples, dropping the nesting and body
limits, the count of reserved words and "(explicit)" after Float; 2998
tokens. Round 3 is a defect round: its rates measure the defect, and
round 4 on the corrected sheet through the same channel (Sonnet 5.5
first; gpt-5.5 when the Codex quota or the owner's key authorization
gives it a channel) is the measurement of U1 to U3. count stays
reserved (R2); the owner waits for gpt-5.5's data before reopening it.
(user)
U9. The cheat sheet says when a refined construction takes
otherwise. Round 4 (tests/readability/2026-10-06-c696747/notes.md,
Sonnet 5.5 on the sheet after U8, through the CLI channel run in an empty
directory with no MCP server) shows the errors U1 to U3 and U8 addressed
gone: no named single argument, rounded() or field-form error in 345
samples, against 43 named-argument lines in round 2. Complete is 79
against round 2's 89 on four items whose slips no changed sentence
touches, and two of them are one gap: Port(8080) otherwise crash with
... on a literal the checker proves valid (superfluous-otherwise,
config) and Done(position: number) without otherwise after if
number is less than 1 then return Help end (missing-otherwise,
todo_cli); the sheet said only that refined construction can fail. It
now says "A literal the checker can evaluate needs no otherwise
(Port(8080)); a variable needs one even after a check", paid for by the
phrase-token sentence, a query comment and "renyi run enforces it";
2991 tokens. The checker is
unchanged (a flow-sensitive refinement, which would read the check, was
the alternative and is declined for now). The owner also ruled that the
notes' item-by-item explanation satisfies the five-point rule for the
fall of Complete without a decision entry, since no change caused it,
and that gpt-5.5 does not run on this sheet for now: the rounds continue
on Sonnet, and the freeze still needs the second gating model (R8).
(user)
V. The gap audit and the road to self-hosting (session 6)#
On 2026-10-06 the owner set the goal beyond the readability scores and
answered the questions of the gap audit (docs/GAPS.md) in two batches of
four, the recommendation first in each.
V1. The goal is a self-hosted language with users; the grammar freezes
by decision. The readability rounds did their work (the sheet and the
corpus are what the gating model reads at 90, 100, 79, 40); the aim from
here is a language that stands on its own: a front end written in Renyi
with the Rust VM as the runtime, a formal grammar and a reference, first
users among people who build agent workflows and among learners, and a
corpus that future models meet in their training data. The grammar is
frozen by a decision entry rather than by the thresholds of
03-readability-test.md, and that entry is written only after the
implementation does what the design documents say: stage 1 of
docs/GAPS.md section 7 (the defects, the promised checks, the four
parsed-but-empty features, the document corrections, CI and the
conformance suite) comes before the freeze, then the formal grammar and
the reference, then the self-hosted front end, then the milestones M4 to
M6. The repository stays private until the owner says otherwise.
Supersedes the freeze-by-measurement sentences of H2, R1, R8 and U9; the
readability harness remains a measurement the owner can ask for. (user)
V2. Indentation carries no meaning, continuation lines included. The
parser contradicted C2: a statement continued on the next line only when
that line was indented deeper than the line that started it, and a
documentation clause continued on deeper lines (sketch section 1 described
both). The owner chose to make the language indentation-insensitive
outright rather than record the exception. A statement or clause now ends
at the newline unless a bracket is open or the next non-blank line starts
with a continuation word (where, sorted by, group by, collect,
sum, count, first, any, all, returns, or fails with,
needs, for any, with, and, or, and inside an example: is
and fails with); the value after be or to may start on the next
line. otherwise is not a continuation word: at the start of a line it
opens the branch of an if or match, so the otherwise that guards a
value stays on the line of that value and the formatter breaks inside the
parentheses of the longer argument list, the call's or the fallback's,
instead (otherwise-line is the error for an otherwise that starts a
line where no branch can). return keeps its value on its line, since return
alone is a statement and the next line could start one. The free text of
purpose:, tags:, see also: and deprecated: runs to the end of its
line. The corpus was rewritten by the formatter (eleven otherwise lines
and three return lines joined); no documentation clause of the corpus
wrapped. Sketch sections 1, 13 and 16 amended. (user)
V3. Ordering is Less, Same, Greater. The library has said
Same since the declaration files were written, because Equal is the
name of the equality ability and a variant of that name would read as a
type test in when Equal then. C3b's table names the result of
compare; it is read with Same in place of Equal. Supersedes the
variant names of C3b. (user)
V4. The phrase table lives in the syntax sketch. C4a said the fixed
phrase table is printed in full in the cheat sheet; U8 and U9 shortened it
to three examples to pay for the library parameters and the
refined-construction sentence. The table's normative place is section 17
of 02-syntax-sketch.md, and the language reference once it exists; the
cheat sheet shows examples. Amends C4a. (user)
V5. The nesting and body limits are compile errors: depth 4, 60 lines.
D4 and O3 promised them and the checker never enforced them. A statement
nested deeper than four blocks (an if, match, loop or run
concurrently body adds one; the function body is depth 0) is
nesting-depth, and a function body whose statements span more than 60
source lines is body-length, each with the fix "move the inner part
into a function". The corpus's deepest body is 3 and its longest 30
lines, so nothing in it changes. (user)
V6. The four parsed-but-empty features. only to gets its runtime
now, as section 3 of 06-runtime-guarantees.md designs it (P3 had
scheduled it in M4). deprecated: gets tiers 1 and 2 of C8c now: a call
to a deprecated definition is a warning that renyi check --strict turns
into an error, and renyi index drops the definition; renyi migrate
(tier 3) waits for the package manager. expose as tool gets renyi
tools, which prints the manifest of D6 (JSON Schema from the
parameters, the description from purpose:, the permissions from
needs) and the checker rejects a parameter or return type that JSON
cannot represent; renyi serve --mcp waits for M5. process and
foreign leave the cheat sheet, and the checker rejects them in a
needs clause (capability-unavailable) until the package manager
brings std.process and the FFI (M4). Nothing in the frozen surface
parses and does nothing. (user)
V7. Task independence is a checker rule. E1 promised that a race
cannot be written, and S2 delivers it only because tasks run one after
the other. The checker now enforces independence: a task of run
concurrently may not set a mutable binding declared outside the block
and may not read a binding declared by another task of the same block;
the violation is task-independence with the fix "bind the result with
let inside the task, or run the statements in sequence". The body of a
concurrently query is one expression per item and is independent by
construction. Real concurrency (green threads) remains a runtime
improvement that the rule makes safe. (user)
V8. CI and the conformance suite. D1 and H6 named them; neither
existed. A GitHub Actions workflow runs cargo fmt --check, cargo
clippy --all-targets, cargo test, the cheat-sheet token gate and the
corpus lint on every push; the private repository's minutes are the
owner's. The conformance suite is tests/conformance/: Renyi programs
with their expected standard output, exit code and diagnostics, in files
a compiler written in Renyi can be tested against without the Rust
crates; the corpus's reference outputs are its first members. (user)
V9. A passed function runs under the grant in force where it is
called. B1 charges the needs of the function actually passed to the
call site that passes it, whatever the parameter's type lists, and a
higher-order function declares only its own effects. At run time the
grant stack of Q1 applies as everywhere else: the passed function runs
inside the frame of the function that calls it and is narrowed by that
function's needs (sketch section 3). A function value stored in a
collection and called later is charged nowhere statically and is refused
by the grant stack at run time (docs/GAPS.md, 1.11). (user)
V10. Iterable is one method, to_list. public ability Iterable of
Item declares function to_list(self) returns List of Item, without
needs: an implementation's method never declares effects
(method-signature otherwise). for each and the queries walk any type
that implements it, through the list to_list returns, after the
built-in collections; the item type is the implementation's type
argument (ability Iterable of Card for Deck), with the implementation's
for any parameters substituted. A cursor protocol (next) and
constraints with type arguments (where Bag can Iterable of Item, open
item R3-2) are not in v1. Supersedes the Iterable of the early
core-ability list, which was declared nowhere. (user)
V11. The grammar is frozen. The surface syntax is what
02-syntax-sketch.md and docs/cheatsheet.md describe at commit
dc58bb3 (2026-10-06), with the corpus under examples/ and the
conformance programs under tests/conformance/programs/ as its
witnesses: the reserved words and phrases of sketch section 17, the
clause grammar of sections 2 to 15, the canonical layout of section 16,
and the core abilities of section 5 with Iterable (V10). From here a
change to the surface is a new decision entry that names what it
supersedes; it lands in the sketch, the cheat sheet (within its budget),
the formatter and the conformance suite in one commit, and the old
spelling gets the new one as its fix (C4). The open items of sketch
section 18 (R3-2) and docs/GAPS.md section 6 are not surface changes
until decided; library additions (04-stdlib-sketch.md) are not surface
changes. The formal grammar (EBNF) and the language reference are
derived from the frozen sketch in stage 2; what they find unclear is
settled by an entry, not by the implementation. (user)
V12. Line breaks after commas and before is and fails; one spelling
per construct. Three rulings the formal grammar required, all on the
line rule of sketch section 1. (1) A line break after a comma carries no
meaning wherever the comma stands: a needs list, a for any list, an
exposing list, a can Compare by list, a with update or the sources
of a query may continue on the next line, as the example of section 11
always showed; the formatter breaks a needs clause wider than the line
one capability per line, indented once more than the clause. (2) is
and fails are continuation words everywhere, not only inside an
example:: the continuation words are one list read without context,
which the grammar's token filter and a self-hosted lexer can state; the
formatter breaks before them only in an example. (3) The parser accepts
one spelling of each construct, since the formatter never changes a
token (section 16): it rejects, with a fix, a trailing comma in a
bracketed list, a variant with empty parentheses in a declaration or a
pattern, a space between a dot and the member after it, an otherwise
arm that is not the last of a match expression, a head and end on
one line, a hole in a test name, a capability scope, a recording's path
or an external name, and public on an ability's method
(public-method); and it accepts, as section 1 says, a line break
inside brackets before a dot or a call's parenthesis. The grammar
docs/grammar.ebnf and its test crates/renyi_syntax/tests/grammar.rs
state the surface under this entry. (user)
W. The self-hosted front end (session 8)#
W1. The syntax tree's JSON is the derived JSON of the Renyi AST.
compiler/ast.ry declares the syntax tree as Renyi types, one per
construct, each can ToJson; the document renyi parse --json prints is
their derived JSON: a record is an object whose keys are its fields in
declaration order, a variant is an object with kind first and its
fields after it, a maybe without a value is null, a list is an array,
and a span is {start, stop} in character offsets, as Renyi's text
indices count (the Rust encoder converts its byte offsets). The Rust
encoder (crates/renyi_syntax/src/json.rs) produces the same document,
so the two front ends can be compared byte for byte; the previous
document (node keys, line and column positions) is gone, in one
change. The names of the Renyi types keep the derived document
unambiguous: no two sum types in the compiler's scope share a variant
name (IsValue beside the operator Is, the lexer's MemberName beside
the expression Member), no field is a reserved word (exposed for
exposing), and span is the last field of every node. (user)
W2. The front end written in Renyi lives in compiler/. The modules
are ast (the tree), lexer, parser, parse (the command line:
renyi run compiler/parse.ry [--declarations] <file> prints the tree)
and tokens (the token dump, as renyi tokens prints it); they are
named by their file stems and import one another by those names, since
the directory of the main file is the project root (J17). They are Renyi
programs like any other: renyi check clean, in canonical layout
(renyi format compiler/*.ry), within the size limits of V5, run by the
Rust VM. The parser's import ast exposing ... names every node type,
wider than any line, so the formatter breaks an exposing list wider
than the line after its commas, one name per line indented once, as V12
breaks a needs clause (reference section 16). (user)
W3. The judge is a Rust integration test.
crates/renyi/tests/selfhost.rs runs the Renyi parser on the VM over the
corpus, the conformance programs, the compiler's own sources and, with
--declarations, the library declarations, and compares its output with
renyi parse --json byte for byte; a program the Rust parser rejects
must make the Renyi parser fail. It runs in cargo test and in CI, so
the two front ends cannot drift apart. renyi parse --declarations
exists for it: a library declaration file's functions have no bodies.
(user)
W4. The lexer and the parser come first. The bytecode file format or
loader, and the performance items of docs/GAPS.md section 7 (in-place
collections, string building, a pattern cache), wait until the
self-hosted checker or emitter needs them or a measurement shows the VM
too slow; the parser's own run over the corpus is the first measurement.
(user)
W5. The checker is the next piece, transcribed from crates/renyi_check.
The checker written in Renyi lives in compiler/ beside the parser, one
module per Rust file where the Rust has one: lists, report (the
diagnostics, their rendering and the layout checks of renyi_syntax),
effects, suggest, types, refine, declare (world.rs: the
modules, types, functions, abilities and implementations of a project
and the library, resolved after every module is in), bodies
(check.rs: every function body, test, example, constant and refinement
condition, with the Rust checker's mutable state as a Checker record
threaded through every function) and the command line checker
(renyi run compiler/checker.ry [--json] [--strict] [--library <dir>]
<file>..., which reads the library's declaration files, the file and
its imports, and prints what renyi check prints). It is written in one
pass as a transcription, as the parser was, and committed as one piece;
every message and fix is the Rust checker's, verbatim. (user)
W6. The profile of the VM waits until the checker exists. Where the
3.9 s of the parser's run on parser.ry go is measured after the
checker is written in Renyi, so that one profile covers the parser's
and the checker's runs; the checker's run over the compiler's own
sources is the second measurement. (user)
W7. The judge of the checker is full equality with renyi check --json.
crates/renyi/tests/selfhost.rs runs renyi run compiler/checker.ry
--json over every program of the repository (the corpus, the
conformance programs and the compiler's own sources; the library
declaration files are not checkable programs) with and without
--strict, and compares the output with renyi check --json
[--strict] byte for byte (codes, severities, positions, messages, fixes
and order) and the exit status with the Rust one; a program the Rust
parser rejects must make the Renyi checker fail. It runs in cargo
test and in CI with the parser's judge. (user)
W8. The checker also produces the reference table the VM's compiler
needs. bodies.ry records what check.rs records for the VM: the
target of every name (Target: a function, an ability method, a
constant, a type, a variant, an ability), the kind of every number
literal (NumberKind), the context type of every call whose result the
context alone decides, whether every otherwise guards a fallible
value, and the literals and results noted while a body is checked
(Reference, SpanTy), as Renyi values keyed by span. They are
produced now and judged when the emitter exists, which is the piece
that consumes them. (user)
X. The speed of the VM (session 8)#
X1. The VM is optimized in development builds. cargo test and CI
run the renyi binary of the development profile, where the parser
written in Renyi took 5 s on parser.ry and the checker 32 s on
bodies.ry; the release profile runs both four to five times faster
(1.0 s and 5.5 s). The workspace manifest sets opt-level = 3 for
renyi_vm and for every dependency in the development profile, so that
the judges, CI and every renyi run from a development build get the
release speed of the interpreter while the front end, the checker and
the binary keep their fast rebuilds. (user)
X2. slice(start, stop) on lists. The lexer written in Renyi cut a
token's text one character at a time (chars.at(index) and a text
concatenation per character: 12 percent of a checker run), and no
composition of the existing methods takes a middle run of a list in
time proportional to its length (take and drop copy from the
start). The prelude gains slice(self: List of Item, start: Integer,
stop: Integer) returns List of Item: the items from start to stop,
the end exclusive, the bounds clamped to the list as take and drop
clamp theirs; the sketch, library/std, the VM and the cheat sheet
change in one commit (a library addition, not a surface change under
V11). The lexer's slice is one slice and one join. Measured on the
checker's own 7500-line bodies.ry: 18 percent off the checker's run
and 17 percent off the parser's. (user)
X3. The interpreter loop is rewritten for speed before the emitter.
The profile (docs/GAPS.md, status at the end of session 8) shows the
time spread over the VM's plain operations, about 35 ns each: Load,
Field (a linear search of the record's field names on every access),
Binary, Call and Return, with every step returning a 48-byte
Result<Option<Value>, Interrupt> and every Value 40 bytes wide. The
owner chose the deep change over the three cheap ones measured
(arguments left in place at a call and one handler stack for all
frames, 5 to 8 percent; a cache of the field index, about 8 percent; a
fast path for is on records, about 3 percent): the dispatch loop
keeps the running frame's state in locals and returns nothing per
operation, Value is slimmed by boxing its wide variants, and the cheap
changes come with it. The target is 1.5 to 2 times on the parser's and
the checker's runs, measured with X4; the bytecode emitter waits for
it. (user)
X4. renyi run --profile. The VM carries its own profiler: a timer
raises a flag every half millisecond, the operation running when it was
raised gets the sample, every operation, call and library primitive is
counted, and the report (samples by function and operation, by
function, by operation kind with the primitives by name; the counts)
goes to the standard error when the run ends. It is a development aid
like renyi tokens, named in appendix B of the reference and in
05-agent-tooling.md. (user)
X5. The bytecode emitter writes a file. The compiler written in
Renyi will emit the VM's own instruction set (crates/renyi_vm/src/
bytecode.rs) into a file that renyi run loads and runs, rather than
hand its checked tree and references to the Rust compiler in one
process (a loader). The file format is the contract between the two
halves and must be kept equal to bytecode.rs; the Rust front end can
then be replaced without touching the VM, which is the point of
self-hosting (decision W2). The format and the loader are designed when
the emitter is written, after the residue of stage 1 (the owner's
order, below). (user)
X6. The binary allocates through mimalloc. The profile after X3
shows the remaining time spread over the plain operations, with every
record, list, text and frame going through the system allocator, which
is slow on Windows. The owner chose to add mimalloc as the global
allocator of the renyi binary (one dependency of C code, built by
cc on CI's Ubuntu and on MSVC; a decision in the territory of S1),
on the condition that it buys at least a tenth. Measured in the release
build, best of five, the two binaries run back to back: the parser on
parser.ry 811 to 496 ms, the checker on lexer.ry 510 to 389 ms, on
bodies.ry 2712 to 2138 ms (1.3 to 1.6 times); it stays. Asked in the
same batch: the development profile keeps the front end and the
checker unoptimized (X1 stands), and the residue of stage 1 (docs/
GAPS.md, section 7, the status of session 7) is finished before the
emitter is written. (user)
Y. The residue of stage 1 (session 8)#
The owner's order after X6 was to finish what stage 1 of docs/GAPS.md
(section 7) left open before the bytecode emitter: entries 1.8, 1.14,
1.17 and 1.18 of the audit and the sketch's open item R3-2. Each was
read in full and the design choices asked as one batch of four.
Y1. A denied primitive that cannot fail crashes; the server fails.
Decision J11 reports a scope denial through the primitive's ordinary
error type, which a primitive without a failure type does not have:
filesystem.exists, environment.get and their kind crash when the
effective grant does not allow the call, and the crash names the
function whose needs narrowed the grant. This is now the rule (the
reference, section 11), not a gap: giving such primitives a failure
type would make every call to them take otherwise. The server joins
the modules that fail: serve outside the grant is
StartError.PermissionDenied(port), past a budget the new
StartError.OverBudget(port) (library/std/server.ry). Containment of
a path scope stays lexical, written into the reference: a scope
contains a path by its text once ., .. and the separators are
normalized, nothing is resolved on disk, so a symbolic link under the
scope reaches wherever it points. Canonical paths would cost a system
call per check and change the answer with the state of the disk, which
a replay cannot reproduce. (user)
Y2. A replay compares the recording's grant with the needs.
06-runtime-guarantees.md says a replay checks that the recording does
not exceed the grant it is replayed under, and the implementation
checked each recorded call's capability but never the grant header.
Now replay_with checks the header first, then the calls: every
capability the header names must be covered by the effective grant of
the test or program, else the replay is refused naming the capability
and the grant. The six fixtures of the corpus already fit their tests'
needs. (user)
Y3. Collections keep the derived Equal and Hash. A declared
equals decides is and is not (stage 1); Set items, Map keys,
distinct, to_set, contains and index_of compare and hash by
structure and consult no declared equals or hash, as the ability
table of the library sketch said and the reference now says (section
5). Consulting them would make a hash depend on user code and a
collection's behaviour on the implementation in scope, which the
derived form avoids; a type that wants its own notion of equality in a
collection keys it by a field. In the same entry: repeat, pad_left,
pad_right and rounded take a count that fits a machine word, and a
larger Integer is a crash, this Integer is too large for the
operation, written into the reference (section 7) rather than made a
failure. (user)
Y4. The loop unwinds its operands; a refinement sees its own field;
R3-2 waits. Entry 1.18 had two parts. (i) break or continue as
the outcome of an if or match expression nested in another
expression left the interrupted expression's operands on the stack: a
statement loop now marks the operand stack's height at its entry
(Op::MarkStack) and every break and continue drops the operands
above the mark (Op::UnwindStack) before it jumps, so the stack of a
long loop no longer grows and the emitter of X5 can assume a fixed
height at every loop boundary. (ii) The reference says a refinement is
a condition "over the field's name", and both checkers bound every
field of the record or variant: a field's condition now sees that field
alone (a subtype's value), and a condition that names another field
of the type is the error refinement-field, with the fix to check both
fields where the value is built; the condition code of the VM still
takes every field, unchanged. The sketch's open item R3-2 (constraints
with type arguments, for any Bag where Bag can Iterable of Item) is
deferred until after the emitter: it needs a design round of its own
and nothing in the compiler waits on it. (user)
Z. The bytecode file and the emitter (session 8)#
Decision X5 set the emitter's shape: it writes a file the VM loads. What the file is, how the VM reads it, how the emitter written in Renyi is judged and where the commands go were asked as one batch of four, answered with the recommended options.
Z1. The bytecode file is the derived JSON of Renyi types. The
format is declared once, as the types of compiler/bytecode.ry
(Program, Code, Op and the rest, each can ToJson), and a
bytecode file is their derived JSON (library sketch, section 7), as the
syntax tree's JSON is the derived JSON of compiler/ast.ry (decision
W1): a record is an object whose keys are its fields in declaration
order, a variant an object with kind first, a maybe without a value
null, a list an array, a number a JSON number, and every span counts
characters. The first field is format, the version of the layout; the
extension is .ryc. The emitter written in Renyi builds the Program
value and prints it with json.render_indented; the Rust side
(crates/renyi_vm/src/file.rs) renders the same document from the VM's
own Program through the JSON writer of renyi_syntax, which the judge
of decision W3 already holds equal to Renyi's. A binary layout would be
smaller and faster to load, and would need a second definition of every
structure on each side; the JSON is read by any tool, diffed in a
review, and defined by the types the Renyi compiler needs anyway. The
maps of the VM's program (impls, method_index) are written sorted,
so that the document is a function of the program alone. Field names
that are reserved words of Renyi (function, module, returns,
fails, needs, set, ability, count, purpose) are renamed in
the file (function_id, owner or module_name, result,
failures, capabilities, set_type, ability_id, size,
summary), and a number constant is written as its digits in a string,
so that an Integer past a machine word and a Decimal's scale
survive the trip. (user)
Z2. The loader is hand-written over the VM's own JSON reader. No
serialization crate: file::load reads the document with
natives::json::read_json, the reader behind json.parse, and walks it
field by field into the VM's Program, refusing anything that does not
fit with the path of the place (the file.codes[3].ops[7].target: ...)
and refusing a format that is not the one this VM reads. After the
walk a consistency pass checks every index, a function's code, a
constant's code, an example's codes, a jump's target, a slot against
the code's locals, a constant against the code's table, a type, a
field site and a result type against the program's tables, so that a
file written by hand cannot send the VM past a table. This keeps the
dependency list at decision S1's (the reader exists already) and the
format readable by the Renyi compiler itself one day. (user)
Z3. The judge is byte equality, then behaviour. The emitter written
in Renyi is right when renyi run compiler/compile.ry <file.ry> --to
a.ryc writes, byte for byte, what renyi compile --to b.ryc <file.ry>
writes, over the corpus, the conformance programs and the compiler's own
sources, and when both refuse every program the Rust checker refuses
(crates/renyi/tests/selfhost.rs, as decisions W3 and W7 judge the
parser and the checker). Behaviour is judged by running: every run
case of the conformance suite runs a second time from the .ryc file
renyi compile writes for its program and must print the same output
and exit the same way (crates/renyi/tests/conformance.rs), the VM's
own test renders a program, loads it back, renders it again and runs
both (crates/renyi_vm/tests/file.rs), and the binary's test runs,
records and reproduces a program from its file
(crates/renyi/tests/compile.rs). Byte equality is the stricter judge
and the one that locates a difference; the reruns catch what a file
loses on the way (a span, a constant's digits, a fixture's path). (user)
Z4. renyi compile, and the file loads by its extension. renyi
compile [--to <file.ryc>] <file.ry> checks the program with its
imports and writes its bytecode, by default <name>.ryc in the working
directory, as renyi record names its recording; its diagnostics are
those of check, and a program with errors writes nothing. renyi
run, record, test and reproduce take a .ryc file wherever they
take a .ry file and load it instead of checking and compiling, so a
program's main, tests and examples run from the file alone; the
replays fixtures are found beside the source paths the file remembers.
The run manifest's code hash of a program loaded from a file is the
SHA-256 of the file's bytes, since the definitions main reaches are
not there to hash: a recording made from a .ryc reproduces from the
same .ryc. No separate load command and no --bytecode option: the
extension says what the file is. In the same entry: the spans a program
keeps, in process or in a file, count characters, as the syntax tree's
JSON does, so that a program loaded from a file is the program compiled
in process; the compiler converts the parser's byte offsets when it
emits, and a module's source is remembered as its path and the
character offsets of its line starts, which is what a crash location
and a test report need. (user)
AA. The rename of set (session 8)#
set (session 8)#AA1. set name to expression becomes change name to expression.
The owner asked whether to rename set to change and to forbid every
other way of changing a binding. The second half was already the rule:
the grammar has no =, a name is bound once per function (shadowing),
and set on a let mutable binding was the only way to change a value.
The rename stands on its own: set had three meanings, the statement,
the Set type and the Map.set method, and change x to x + 1 names
what happens to an existing binding. A surface change under decision
V11: this entry, then the reference (sections 1, 6, 8 and 17), the
grammar, the cheat sheet, the formatter, both front ends (Word::Change
and the statement Change of the tree and of its JSON; the reserved
list of compiler/lexer.ry, change_statement in compiler/parser.ry),
the checker's fixes (writechange x to x.method(...)`), the corpus,
the conformance programs, the compiler's own sources, the crates' tests
and the lint, in one commit.setleaves the reserved words andchangejoins them (88 words still);SetandMap.setare unchanged.
The readability rounds undertests/readability/` keep the grammar they
measured. (user)
AB. Constraints with type arguments (session 8)#
AB1. A constraint takes the type arguments its ability declares, and
the collections are Iterable. Open item R3-2 of the sketch, deferred
by Y4 until after the emitter, asked as a batch of four and answered
with the recommended options. (i) for any Bag, Item where Bag can
Iterable of Item: a constraint names an ability with as many type
arguments as the ability declares (type-arity otherwise, with the fix
writeBag can Iterable of Item), and the arguments are any types in
scope: the clause's own parameters, concrete types and composites. An
ability's requirement follows the same rule with the ability's own
parameters in scope (`ability Countable of Item where self can Iterable
of Item`). Inside the body a parameter constrained to `Iterable of Item`
is walked by `for each` and the queries with items of type `Item`, and
a method of the ability called on it has the ability's parameters
substituted (`bag.to_list()` is a `List of Item`). At a call site the
argument's type must have the ability with matching arguments: those of
its implementation, with the implementation's parameters read as the
type's arguments (`Iterable of Item for Stack of Item` gives `Stack of
Text` the argument `Text`), or those a constraint of its own gives it;
matching binds what the constraint leaves open, so `Item` is inferred
from `Deck`'s `Iterable of Text`, and a mismatch is `missing-ability`
naming the arguments (totalneedsIterable of Integer, whichDeckdoes not have). (ii) The prelude implements Iterable for List of
Item, Set of Item, Map of Key to Value (its pairs), Range
(Integer) and Text (its characters), so that a generic walker
accepts a list and to_list exists on each; the loop's own rules for
the collections are these implementations now, an implementation head
takes full types as arguments (ability Iterable of Pair of Key, Value
for Map of Key to Value), a declaration file holds an implementation
with its methods' heads alone, and the VM dispatches an ability call on
a base value by its declared type. The alternative, a constraint that
only a declared implementation satisfies, would have refused a list to
every generic walker. (iii) An ability named without the arguments its
parameters call for, Bag can Iterable, is type-arity, the rule the
implementation head already followed; an item type left unknown would
have been an existential for little gain. (iv) One implementation of an
ability per type, whatever the arguments: a second is
duplicate-implementation, since dispatch is by the value's type alone
and a loop needs one item type; two implementations were accepted
silently before. In the same entry: an implementation's methods are as
visible as their ability, which the reference said and the checker did
not do (private-name on a public ability's method from another
module). A surface change under decision V11: this entry, then the
reference (sections 2, 3, 4, 5 and 8, appendix A), the grammar
(Implementation takes types after of; ImplDeclaration for a
declaration file), the cheat sheet, both front ends, the library and its
sketch, the conformance suite (four cases) and the checker's tests, in
one commit. (user)
AC. Packages (session 8)#
AC1. Packages: a static registry, JSON manifests, the package name as
the first segment of an import, and the first slice of M4. The owner's
batch after the judges ran from bytecode, four questions answered with
the recommended options; the rules that carry them out are this entry.
(i) The registry is a directory or a URL, not a service:
<registry>/<name>/versions.json lists the versions,
<registry>/<name>/<version>/package.json holds the package's name,
version, purpose, dependencies, the toolchain that published it, every
source file's path with its SHA-256 and the effect manifest of Q1 (for
every public function, its transitive capabilities and failure types),
and the source files lie beside it. A package's content hash is the
SHA-256 of its package.json text, spelled sha256: and the hex digest
as the index spells hashes. A directory registry (absolute, or relative
to the project root) is read in place; a http:// or https://
registry is fetched into .renyi/packages/<name>/<version>/ under the
project root by renyi fetch and by renyi add, which check every
file's hash and recompute the effect manifest from the sources, refusing
a package whose claimed manifest differs: Q1's recomputation by the
registry is the client's until a registry with signatures exists (R7-2).
renyi publish [--to <directory>] writes a project into a directory
registry (a URL registry is published through its local copy): the
project must check clean, the version must be at least what the
semantic diff against the highest published version demands (G1: a new
major when a public signature went or changed, a new minor when one
came, else greater than the previous), and a published version is never
overwritten. (ii) The manifest is JSON. renyi.json in the project
root holds name, version, purpose, dependencies (package name to
the version required), registry and budgets (the thresholds of R7,
public_per_module, effect_paths_per_module and
fan_out_per_definition, which renyi index --budgets reads when they
are there); the lockfile renyi.lock.json beside it holds packages,
every package the program reaches with its name, version and
hash, sorted by name, written by renyi add and renyi update and
read by every other command. A project is the directory holding
renyi.json; a program's project root is the nearest such directory in
its file's directory or above it (up to the working directory for a
relative path), else the file's directory as before (J17), and its own
imports resolve from the root. A version is major.minor.patch; a
requirement names a version and means the same major and at least that
version; a program holds one version of a package, the highest one every
requirement allows, and requirements that disagree on the major are an
error. One format for the recording, the run manifest, the bytecode file
and the manifests, read by one reader (crates/renyi_json, the VM's
reader moved out); the alternatives were a package.ry in Renyi syntax
(a surface change under V11) and TOML (a new dependency). (iii) The
package name is the first segment. import <name>.<path> reaches the
dependency's file <path>.ry from the package's root and import
<name> its root module <name>.ry; inside the package a module header
is the path from the package's root (module fetch), and the checker
names the module <name>.fetch, the root module <name>; an import
inside a package that names one of the package's own dependencies
reaches that dependency, any other its own files; at the program level
an import reaches a package only when the manifest lists it as a
dependency. A dependency wins over a directory of the project with its
name; renyi add refuses such a name and std. No new keyword, and no
package name in the headers. (iv) The first slice is packages: the
manifest, the lockfile, renyi add <name> [<version>] (resolve, fetch,
print every public function's effects and failures, write both files),
renyi update [--accept-effects] (every dependency to the highest
version its requirement allows; one whose effects widen is refused
unless the flag is given and main's grant covers them), renyi audit
(every dependency's transitive effects against main's grant, and the
capabilities of the grant no dependency uses), renyi fetch, renyi
publish, the dependencies with their hashes in the run manifest, which
renyi reproduce compares (Q2), and the thresholds of R7 in the
manifest; std.process with the capability process is the next slice
and the foreign function interface (foreign, F0) the one after. Across
a package boundary the static coverage rule checks the kind of a
capability and the grant stack its scope, as reference section 11
already said, and the error names the package ("announce (package
greeting 1.0.0) needs console, which main does not declare"). A
package whose package.json differs from the lockfile is
package-mismatch on the import, a dependency of the manifest that the
lockfile or the registry lacks package-missing, and a manifest, a
lockfile or a package.json that cannot be read manifest-invalid. The
resolver is crates/renyi_package, used by the checker and the binary;
Bytes.sha256() joins the prelude so that the front end written in
Renyi verifies a package as the Rust resolver does
(compiler/project.ry), and the judges hold the two equal over the
projects with a dependency in the conformance suite
(tests/conformance/packages/). The front end written in Renyi reads the
manifests through std.json, whose maps keep one value per key, so a key
given twice is refused by the Rust resolver alone, as is a budget spelled
1.0 or 1e2 or a version part beyond 64 bits; the two are left to
differ there. (user)
AD. The diagnostics of the front end in Renyi (session 8)#
AD1. The front end written in Renyi reports what the Rust front end
reports: every diagnostic with its code, message, span and fix, and the
same recovery. The "2" of the owner's answer "1+2" of 2026-10-07
(stage 3 and, beside it, this). Until this entry compiler/lexer.ry
and parser.ry stopped at the first problem with a message and an
offset, and the judges of crates/renyi/tests/selfhost.rs asked only
that both front ends reject the same programs; a toolchain in Renyi
that answers for renyi check and renyi compile must say what they
say on a broken file too. The rule: (i) the lexer and the parser in
Renyi carry every error site of crates/renyi_syntax/src/lexer.rs and
parser.rs with the code, the message, the span and the fix verbatim,
and recover where the Rust ones recover (the lexer reads on after a bad
character, which becomes an ErrorToken; the parser skips to the end
of the line after a bad import, statement, clause or example and to the
next item at the margin after a bad item, and keeps the partial tree);
the parser's Cursor carries the diagnostics and its failure Halt
carries the cursor, so that a caller that recovers reads them off it.
(ii) renyi run compiler/parse.ry prints the tree, then the
diagnostics as renyi parse --json prints them, and exits as it exits;
checker.ry and compile.ry print a rejected file's diagnostics as
renyi check and renyi compile do, and follow the imports of its
partial tree as the Rust resolver does. (iii) The three judges compare
the standard output and the exit status on every program, rejected
ones included (the emitter judge compares the files besides when both
wrote one); lane probes exercise the error sites no program in the
repository reaches, and two conformance cases hold a sample. (iv) The
rule of W7 extends to the front end: a new diagnostic, message or fix
in the lexer or the parser of crates/renyi_syntax is the same change
in compiler/lexer.ry or compiler/parser.ry in the same commit. The
alternative, one syntax diagnostic per rejected file, was what
existed: enough for the trees, not for the toolchain. (user)
AE. The process module (session 8)#
AE1. std.process starts a program and waits for it: one call per
run, a status other than 0 a failure, the scope the program's name as
spelled, the parent's environment inherited. The second slice of
stage 3 (M4), after packages (AC1), in the order the owner chose. The
four questions of 2026-10-07 and their answers: (i) the shape of the
module: execute(program, arguments) and attempt(program, arguments)
run the program to its end and report a Completion (the status, the
standard output as text and as bytes, the standard error as text);
execute_with and attempt_with take an Options record (a working
directory, variables added to the environment, text for the standard
input, a time limit past which the program is killed and the call fails
with Timeout) and defaults() sets none; no handle, no interactive
reading or writing, no background process: one primitive call is one
record of a recording, and a handle would sit badly with tasks that run
one after the other (S2); a handle can be a later entry when a program
needs one. (ii) A status other than 0 is the failure Exited(program,
status, output, errors) of execute, so that a caller handles it like
any failure (as http.get fails on a status outside 2xx, K2);
attempt reports any status as a completion, for the programs whose
status is an answer (grep, diff). (iii) The scope process("git")
is matched by the program as the call spells it, text for text: the
rule J11 states ("a program name contains only itself"), the simplest
to explain, and the one under which a package's effect manifest says
exactly which programs the package may start; a full path needs a grant
of that path, and git.exe is not git. The alternative, the file
stem, would have let process("git") start any file so named anywhere.
(iv) The program inherits the parent's environment and working
directory; Options adds to or overrides them. A clean environment
would have made most programs (git wants HOME) need variables
passed by hand, for a capability the grant already limits by program.
The function is execute, not run: run is a reserved word (run
concurrently). The VM's boundary already took the first Text
argument of a process primitive as the scope of its effect and
counted its budget; the module adds the natives, the module's
ProgramNotAllowed and OverBudget, the tests, a conformance case,
and foreign alone stays unavailable (V6). (user)
AF. The foreign function interface (session 8)#
AF1. A foreign module is a declaration file of the project that the
manifest binds to shared libraries; scalars, text and bytes cross the
boundary; the libraries load at run time through libloading and a call
goes through a fixed signature family; a foreign call is a primitive at
the boundary. The third slice of stage 3 (M4), after packages (AC1)
and std.process (AE1), in the order the owner chose; decisions F0 and
F1 named the capability and left the mechanism open. The four questions
of 2026-10-07 and their answers: (i) Bindings are declared, not written
in a new syntax (the surface is frozen, V11): a foreign module is a file
of bodiless public function declarations, each needs foreign and
nothing else, that the manifest's foreign section names ("foreign":
{"libc": {"library": ["ucrtbase", "libc.so.6", "libSystem.B.dylib"],
"symbols": {"renyi_name": "c_symbol"}}}): the libraries are tried in
order and the first that loads is used; symbols renames a function
whose C symbol is spelled otherwise. The resolver tags the file (the
main file by its path from the project root, an imported one by its
qualified name), the checker parses it as declarations and declares it
as a library module (its functions are primitives, recorded like the
library's), and renyi bind <header.h> --module <name> --library
<name>[,<name>...] [--to <directory>] writes such a file from a C
header's prototypes, with the manifest entry. The alternative, an
external clause on a function, was a surface change for what a file
and a manifest entry say as well. (ii) Only scalars, text and bytes
cross: the width types of std.foreign (Int8 to UInt64 and Size,
refinements of Integer), Float (a C double), Boolean, Text (a
NUL-terminated char *, copied each way) and Bytes (a pointer and a
length, two words, parameters only); a result is one of those but
Bytes, maybe Text for a char * that may be null, or nothing.
Records, lists, callbacks and ownership wait for a later slice; what the
first slice carries is what libc and libm take. The checker holds a
foreign module to it: foreign-signature, foreign-type and
foreign-arity (at most six words). (iii) The libraries load at run
time through libloading, a runtime dependency like those of S1, and a
call goes through a fixed family of signatures generated into
foreign_abi.rs by tools/gen_foreign_abi.py (every arity to six,
every pattern of integer-class and double-class words, three result
classes): the one unsafe corner of the VM; no libffi, no C compiler at
run time, and a C function that does not fit the family is reached
through a C wrapper that does. (iv) A foreign call is a primitive at the
boundary: a recording holds it with its result, a replay answers it
without calling, reproduce likewise; a guarded value (only to)
refuses to cross; foreign takes no scope and no budget (a budget
meters the world; a C call is the program's own code); renyi run
prints "this program can call native code through libc" when main
grants foreign (07-system-design.md, section 2.2); and renyi publish
refuses a project with foreign modules, since a package carries no
native code. capability-unavailable goes: nothing waits for M4 any
more. (user)
AG. Machine code for the bytecode (session 8)#
AG1. The VM generates machine code for the bytecode through Cranelift
inside the one renyi binary, per code object once it is hot; the
bytecode file stays the contract between the front ends and the VM, the
compiler written in Renyi is untouched, and the interpreter remains the
reference: a frame whose typed assumptions fail at run time is handed to
it at the op in question. The owner's direction of 2026-10-07:
strengthen performance at the root, ahead-of-time compilation included.
The four options and the choice: (i) Cranelift in the process (chosen):
one binary, no toolchain at run time, and the same backend serves a later
renyi build; (ii) a C or LLVM backend: a compiler at run time, or a
second build pipeline; (iii) a faster interpreter alone: the loop of
decision X3 had reached 3.3 times slower than CPython on integer loops,
near the ceiling of a loop over boxed values; (iv) WASM: another target,
not a speed-up. How it works (crates/renyi_vm/src/native/): infer.rs
runs an abstract interpretation over a code object's stack bytecode and
settles which operands and slots stay unboxed (small Integers, Booleans,
Floats and the bounds of a range, in registers); codegen.rs translates
every op to Cranelift IR over that analysis, arithmetic, comparisons,
branches and range loops in registers and everything else as a call to a
runtime helper that does what the interpreter's arm does on the VM's
stack; runtime.rs holds those helpers and the hand-back (rt_deopt
boxes the registers into the interpreter's frame and operand stack at
the op). The generated code and the interpreter share every op's
implementation (Vm::op_*), so a change to an op is one change. The
conformance suite runs every program a third time with machine code for
every code object (RENYI_NATIVE_HOT=1), and crates/renyi_vm/tests/native.rs
covers the hand-backs: an Integer that leaves the machine word, a guarded
Integer in a typed parameter, a call past the depth of native frames,
failures, crashes and deadlines inside generated code. (user)
AG2. Integer stays arbitrary precision (decision B9): the generated
code computes on i64 with overflow checks and hands the op to the
interpreter, which has the big integers, when a result leaves the machine
word. The alternatives were a fixed-width Integer, a change to the
language, or big integers in the generated code, every arithmetic op a
call. A program that overflows a word at every op runs at the
interpreter's speed; one that never does runs in registers; the result is
the same either way. (user)
AG3. Machine code is on by default for run, record, test and
reproduce and so for the judges; --explain and --profile use the
interpreter, which narrates and counts; --interpret forces the
interpreter. A code object is compiled once the interpreter has run
HOT_FACTOR (2000) times its size in ops of it, and the machine code
takes over at the code's next call or, when the interpreter is inside
one of its loops, at the loop's next turn: the generated function has an
entry at every loop header whose operand stack holds nothing in
registers, which takes the frame's slots into registers under the same
checks as the parameters (a slot that does not fit leaves the frame
with the interpreter for good). Compiling an op costs a few hundred
times running it on the interpreter, so code run once or twice (a
driver, a setup, a short loop) never pays for machine code it would not
use, and a small script compiles nothing; the first rule, "a code
object with a loop at its first call", compiled 130 code objects of the
checker written in Renyi on examples/hello.ry for 0.13 s a run, most
of them loops of a few turns. A range of small Integers is iterated by
both tiers in the same shape (Native::RangeIterator: the next value,
the last and the step, no longer a list of its items), so a frame can
change hands inside such a loop. Measured on the development build:
examples/hello.ry starts in 46 ms either way; the front end written in
Renyi, compiling compiler/lexer.ry with every code object forced
native, generates code for 676 code objects (39,502 ops, 240,713
Cranelift instructions) in 0.42 s, three quarters of it Cranelift's own
register allocation and lowering. (user)
AG4. A bench/ directory with six benchmarks and tools/bench.py; CI
runs them and prints the numbers, it does not gate on them. The
programs: primes.ry (integer loops), strings.ry (text building and
character counting), records.ry (records in lists),
json_round_trip.ry (JSON rendering and parsing), the self-check of the
compiler written in Renyi (compiler/checker.ry on compiler/bodies.ry)
and the start of examples/hello.ry; the first four have CPython twins
next to them, and bench/*.ry are held to renyi check and the
canonical layout like compiler/. The targets the owner set: primes
at least five times faster than CPython (met: 84 ms against 529 ms on
the development build, 6.3 times), the compiler's self-check at least
twice as fast as before (not met by machine code; AG5), hello no
slower (met). (user)
AG5. What the machine code does not do, measured, and what follows:
the VM's own operations are the next performance work, bounded; an
ahead-of-time image (renyi build) and a baseline JIT that inlines the
boxed operations are planned after release 0.1. Measured 2026-10-07 on
the release build (Linux under WSL): the compiler written in Renyi
checking compiler/bodies.ry takes 1.6 s of CPU on the interpreter and
1.5 s on machine code for every code object, plus 0.36 s to generate it;
of its 5.4 million calls none hands a frame back. The time of such a
program is in the values, not in the dispatch: the profile (perf)
puts 32% in the interpreter's loop (of it 12% pushing values on the
stack), 14% in cloning values, 8% in dropping them, 10% in the allocator
(records and lists), 6% in the kernel zeroing fresh pages, 5% in pushing
frames and 4% in field access, and the generated code calls the same
runtime for all of it. So: (i) a bounded round of VM work on those paths
comes next (the stack push, the clone and drop of values, the allocation
of records, the call frame, the boundary of the pure primitives),
measured against bench/, after which positioning and release proceed
whatever the number (the owner's choice over "until the self-check is
twice as fast" and "no VM work now"); (ii) renyi build, an image of
the bytecode with the machine code of this machine that run loads in
place of generating it, is deferred until the machine code wins on
ordinary programs, since today it wins only on numeric loops, which
generate in milliseconds; (iii) inlining the boxed operations (loads,
stores, field access, calls) in the generated code, the road of a
baseline JIT, is deferred the same way. The development aids of the
backend: RENYI_NATIVE_REPORT prints what was compiled, the time per
phase and the hand-back and call counts on the standard error when the
run ends; RENYI_NATIVE_HOT sets the factor (0 compiles everything
at its first call and enters every loop at its first turn);
RENYI_NATIVE_OPT sets Cranelift's optimisation level (none by
default: the optimiser found nothing in helper-call code for twice the
time); RENYI_NATIVE_VERIFY turns Cranelift's IR verifier on. (user)
AG6. The bounded VM round of AG5, done and measured. Kept: a load of
a record or a variant that a read of one of its fields follows reads
the field in the slot; a frame names its grant by an index into a
table, a per-code flag says whether the function narrows the grant at
all, and the locals are filled in one resize; a variant without fields
is built once per type and tag. Tried and dropped: a store of a binding
fused with the load that follows it; the fields of a record or a
variant inline in its allocation. The interpreter's other operations
stay as they are, and the next performance work is the one AG5 defers
until after release 0.1. The owner's answer of 2026-10-07, on
learning that the machine code brings nothing to the compiler written
in Renyi: one bounded round of work on the VM's own operations, then
on to the next item whatever the number. The measure is the count of
user-space instructions and cycles (perf stat, the release build
under WSL, two binaries interleaved, the minimum of three rounds): the
loaded machine of that day moved wall and CPU time by a third between
two runs, the instruction count by nothing and the cycles by a few
percent. The program is the compiler written in Renyi compiling
compiler/bodies.ry on the interpreter. The whole round: instructions
from 15.49 billion to 14.66 billion (-5.4%), cycles from
10.71 billion to 10.27 billion (-4.1%); with the machine
code on, -2.5% and -4.5%. Step by step: (i) the fused field
read in its first form, with the store fusion, 2.0% of the
instructions; (ii) the grant by index, the flag and the resize, another
1.0%; (iii) the fused field read restricted to a slot that holds a
record or a variant, and the store fusion dropped, another 2.0%: the
look at the next op had cost every load and store something, and the
store fusion, which saved a pop and a push, took the record off the
slot, so the field read after it was the slow one again; (iv) the
inline fields (SmallVec<[Value; 3]> in Record and Variant, one
allocation in place of two), tried with the unit variants: 3.4% more
instructions and 0.8% fewer cycles on this program, 8.2% fewer
instructions and 0.6% fewer cycles on bench/records.ry, 0.4% more
and 3.0% more on bench/json_round_trip.ry, 2.2% more and 8.9% more
on a loop that builds a three-field record and reads it; the branch on
every field access and the element-wise build and drop cost what the
second allocation had cost, so the fields went back to a Vec and the
unit variants stayed. On the micro-benchmarks of the interpreter loop
(instructions per turn of the loop, before and after the round): a
counting loop, 713 to 731; a call and return, 1097 to
1100; a primitive call, 1857 to 1906; a field read,
1266 to 1133; a record built and read, 2099 to
1970 (the first three, which the round does not touch, move
with the code layout of the interpreter loop, which a build changes by
up to 3%, so a micro-benchmark alone attributes nothing). Not done,
with the reason: the boundary of a pure
primitive is a move of the arguments into the scratch buffer, a check
that no argument is guarded, a look at the function's needs (none)
and the call, and nothing in it is worth a second path; change x to x
with ... could move the receiver as change x to x.method(...) does
(decision X3) and update the record in place, but that rule is a change
to both emitters and the judges for 34 sites in compiler/, and waits;
a fused LoadField op would take the look at the next op out of the
loop, but an op the bytecode file never carries is a format question
first (decision Z1), and waits too. The time of such a program stays
where AG5 found it: in the clone and drop of values on every load and
return, in the stack traffic and in the allocator, which only the
baseline JIT or renyi build of AG5 can take out. (user)
AH. The niche (session 8)#
AH1. Renyi is the scripting language of AI agents: the language an
agent writes and a person reviews at a glance; the program declares what
it may do, the runtime admits only that, and every run can be recorded,
replayed and narrated. Its first users are people who run automation
with Claude Code, Codex and their like and will not run an agent's
Python blind. The owner's second direction of 2026-10-07: the design
had its innovations but no fixed niche (decision V1 named "people
building agent workflows and learners" as the first users without saying
what the language is to them). The four candidates and the choice: (i)
the scripting language of agents (chosen): every guarantee the design
made (the effect system of sections C and P, the recorded runs of O and
P, the agent tooling of D and the project map, the packages of AC) is
what a person needs before letting an agent's program run; (ii) a
teaching language: the readability is real but the guarantees would be
a side show; (iii) a safe automation language for operations teams: the
same guarantees, but the author would be a person, for whom the English
syntax is slower to write than it is to read; (iv) a general-purpose
language with a safety story: nothing to lead with. The posture stays
general (AH4); the niche says who comes first. docs/design/08-positioning.md
holds the text. (user)
AH2. Four selling points, in this order: effects as capabilities,
declared on every function, scoped, budgeted and enforced at the
boundary, dependencies included; recorded, replayed and narrated runs;
the tooling an agent needs (the project map, the MCP server, purpose:
as syntax, a fix on every error); package effect manifests computed by
the tool and never widened silently. All four candidates offered were
taken; each is a promise the implementation keeps today (the conformance
suite, the judges, renyi audit), which is the condition for leading
with it. (user)
AH3. The English-like syntax ranks second: the positioning leads with the guarantees and shows the syntax as the means by which a person reviews a program at a glance. Leading with the syntax was the project's original pitch (decision A2) and reads as a curiosity; the guarantees are what the first users lack elsewhere. (user)
AH4. No non-goals are written; the posture stays that of a general language. A list of non-goals would read as limits before the language has users; the niche says who comes first, not who is excluded. (user)
AI. Release 0.1 (session 8)#
AI1. Release 0.1 after the machine code, the positioning document and the release engineering land. The alternatives: release at once from the private repository, with nothing to install and nothing to read; or after the embedding API and the LSP of M5, months away. (user)
AI2. The release engineering, all of it: CI builds Linux, macOS and
Windows binaries on a tag and publishes a GitHub Release; an install
script and cargo install renyi (the crate name is free on crates.io,
checked 2026-10-07); a documentation site on GitHub Pages with the
reference, the cheat sheet, the examples and the positioning; a VS Code
extension for syntax highlighting. (user)
AI3. The first acquisition is a starter pack for agents: a skill file, the MCP server and five runnable workflow examples. The alternatives, a launch post or a benchmark table, say what the language is; the pack lets an agent use it in its first hour, which is where the niche of AH1 is won or lost. (user)
AI4. The name stays; a GitHub organisation renyi-lang takes the
repository as renyi-lang/renyi; the owner buys renyi-lang.org. (user)
AI5. The crates are self-contained: renyi_check embeds a copy of
library/std/ under crates/renyi_check/library/std/, and renyi a
copy of docs/cheatsheet.md as crates/renyi/cheatsheet.md; a test in
each crate holds the copy equal to the canonical file, byte for
byte. A crates.io tarball carries only the files under the crate's
directory, so an include_str! of a file outside it compiles in the
workspace and fails from the tarball, which cargo package
--workspace showed on 2026-10-07. The alternatives: the canonical
library/std/ moved under the crate (every path in the documents,
the tests, the judges and the lane scripts changes, and the cheat
sheet still needs a copy); or no crates.io for 0.1. The copies cost
copying the file again after an edit, which the tests demand; the
canonical paths stay. (user)
AJ. Foreign packages: Rust and Python (session 8)#
The owner's question of 2026-10-07, evening: can a Renyi program use Python or Rust packages directly, so that the language extends without a library of its own for everything? Four answers.
AJ1. Rust packages extend Renyi through the mechanism the standard
library uses: a native function registered with the VM under a
declaration file that states its signature, its capability and its
failure types, built into the renyi binary; the registration API is
the half of the embedding API of M5 (decision Q3) that faces the
host. A registered native is checked, recorded, replayed and narrated
like a library primitive, so an extension costs no guarantee; the
standard library's own natives move to the same mechanism, which makes
the API tested by its first user. The alternatives: the C FFI alone
(AF1: a Rust crate as a C-ABI library through renyi bind, with
scalars, text and bytes only, and foreign outside every guarantee),
or nothing until a user asks. (user)
AJ2. Python packages are reached through a typed bridge to a worker
process: a declaration file states each function's signature over the
types JSON carries (numbers, text, booleans, lists, maps, records with
FromJson and ToJson), the VM starts one python process per run
and sends each call as a JSON message, and each call is one primitive
at the boundary, recorded with its arguments and its result. Not
CPython in the process: it opens a hole that can do anything, needs
libpython found at run time and the GIL handled, for a speed a script
does not need. Not std.process alone: one process per call, text
only, the types decoded by hand. The bridge keeps recording, replay,
reproduce and --explain; what the Python side does is outside
Renyi's guarantees, and the reference says so where it says it of
foreign (07-system-design.md, section 4.3). The bridge is an
extension package written against the API of AJ1, the first after the
standard library. (user)
AJ3. A call through the bridge charges one capability, python,
scoped by the package the declaration file binds: needs
python("pandas"). A reviewer reads in the signature that the program
runs Python and which package. The alternatives hide that: effects
declared per function by the binding's author are a promise the checker
cannot verify, and foreign does not tell a C library from Python. A
new capability kind is a change to the reference's section 11 and the
checker's table, not to the surface frozen by V11. (user)
AJ4. The order: after release 0.1, the registration API of AJ1 first, then the bridge of AJ2 and AJ3, before the other items of M5. The alternatives, before 0.1 or after M5, either delay the release or leave the ecosystem question open while the first users arrive. (user)
AK. The registration API (session 8)#
The owner's answers of 2026-10-07, late evening, to the four questions
decision AJ1 left open. The API is crates/renyi_vm/src/extension.rs,
the guide docs/extensions.md, the test
crates/renyi_vm/tests/extension.rs.
AK1. An extension is built into a binary by a crate that depends on
renyi as a library: renyi::main_with(vec![EXTENSION]) is the whole
program of such a binary, and the official renyi is
main_with(Vec::new()). The crate renyi is a library and a binary;
an extension is an ordinary Rust crate that depends on renyi_vm for
the value types and holds an Extension value; a user builds a renyi
with it in a crate of three lines and cargo install --path .. The run
manifest names the extensions a run had beyond the standard library
(extensions, each name version), reproduce warns when they differ,
and renyi version lists them. The alternatives: Cargo features of the
renyi crate, which would make every extension a dependency of this
repository and leave a third party to fork it; or loading an extension
as a shared library at run time, which Rust's unstable ABI would reduce
to the C family of AF1, without lists, maps and records. (user)
AK2. A declaration file and its natives meet by name: an Extension
names its modules with their declaration files and a table of Native
entries, each a module, a function name, the type of the function's
first parameter as the checker spells it, in full (List of Integer) or
by its head (List), or no receiver, and the Rust function;
Registry::verify holds the table and the declarations equal both ways,
and a binary with an extension that fails it does not start. A lookup
takes the entry whose receiver is the full spelling, then the head, then
the entry without one. The standard library is the first extension
(natives::standard()): the eleven lookup functions under natives/
became the same keys as data, two hundred entries, and the two-way check
passed on them at once, which is the test of the API that decision AJ1
asked for. The alternative, a procedural macro reading the Rust
signature and writing the declaration, would move the place a reviewer
reads the capability and the failures into Rust source, for machinery
the table does not need. (user)
AK3. A native of an extension sees what the standard library's natives
see: the Vm, the plain Values of its arguments and the helpers of
renyi_vm::natives (arg, text, int, small, list, map,
Vm::library_record, Vm::fail_variant and the rest); NativeFn is
the one signature. The standard library's two hundred natives are the
proof that it is enough. A typed layer (FromValue, IntoValue, a Rust
signature per Renyi signature) can be laid over it later without
changing it; it is not needed to write an extension. (user)
AK4. An extension declares its capabilities from the kinds of
reference section 11 and adds none: console, filesystem, network,
environment, time, random, process and foreign, with python
to come by AJ3; a new kind is a decision and a change to the reference
and the checker's table. The reviewer's vocabulary does not grow with
the extensions a binary carries, and a native declared under a kind
that takes a scope gets the scope check, the budgets and the guards of
the boundary from its Path or Url parameter without code of its own.
A denied call or one past a budget is reported through the variant of
the function's declared failure type named PermissionDenied,
HostNotAllowed or ProgramNotAllowed, or OverBudget, with the scope
as its one field (the first argument when the capability carries none,
as serve names its port): the rule the library's modules followed by
name, now followed by shape, so that an extension's own error type is
reported the same way; a function without such a variant crashes, as
before. The alternative, kinds registered by extensions, would make the
grant's names depend on the binary. (user)
AL. The Python bridge (session 8)#
The owner's answers of 2026-10-07, late evening, to the four questions
decision AJ2 left open. The bridge is crates/renyi_vm/src/natives/python.rs
with the worker python_worker.py beside it, the checker's rules
crates/renyi_check/src/python.rs, the guide docs/python.md, the
tests crates/renyi/tests/python.rs and the fixtures
tests/conformance/python/ and python_bad/.
AL1. A Python module is bound as a foreign module is (decision AF1): a
declaration file of the project, written by hand, that the manifest's
python section names: "python": {"interpreter": "...", "modules":
{"analysis": {"package": "analysis", "symbols": {"mean": "average"}}}},
interpreter, package (the Python import name; the module's own name
when left out) and symbols optional. Each function of such a file
needs python("<package>") and nothing else, fails with PythonError
and nothing else and takes no type parameters (python-signature); its
parameters are types that can ToJson and its result a type that can
FromJson, or nothing (python-type): what std.json renders and
parses is what crosses, records and sum types included, and the
checker's structural rule decides it. The bytecode file carries the
binding per function (python after foreign; the file is format 3).
The alternatives: declaration files shipped with the toolchain for
known packages, which would make the toolchain answer for the shape of
every Python package it names and go stale with each release of one; or
declaration files generated from Python's annotations, which most
packages do not carry and which say nothing about failures. (user)
AL2. The protocol is one JSON object per line on the worker's
standard input and standard output: {"call": N, "module": "...",
"function": "...", "arguments": [...]} and {"call": N, "result":
...} or {"call": N, "error": {"where": "import" | "call" | "result",
"kind": "ValueError", "message": "..."}}, the arguments by position in
the order the declaration lists them; one worker per run, started at the
first call with the project root on its module path, ended with the
VM. The worker's program is a text the VM passes with -c, so a
project installs nothing; what the Python functions print goes to the
standard error, so it cannot mix with the protocol; a replay never
starts the worker; a result the declaration does not mention is
dropped. The alternatives: a socket or a pipe pair with a framing of its
own, more machinery for the same messages; or one process per call
(std.process), which pays an interpreter start per call and loses the
module-level state between calls. (user)
AL3. The interpreter is the manifest's interpreter when given, else
the environment variable RENYI_PYTHON when set, else python3 and
then python on the PATH (python first on Windows, where python3
is usually the Store's stub); the first that starts and answers the
bridge's greeting is kept for the run. A project that needs a
particular environment (a virtual environment, a version) names it in
the manifest, next to the modules that need it; a machine-wide choice
goes in the variable; a plain setup needs nothing. The alternative, the
PATH alone, would make a project's virtual environment a matter of the
shell the program was started from. (user)
AL4. One failure type for the bridge, PythonError of std.python:
Raised(exception, message) for an exception the function let escape
(its class name and its text), NotCarried(detail) for a result the
declared type does not fit or that JSON does not carry,
Unavailable(detail) for an interpreter that does not answer, a module
that does not import, a function that is not there or a worker that
ended, and PermissionDenied(package) for a package outside the grant
(the rule of AK4); python takes a scope and no budget. A declaration
cannot say which exceptions a Python function raises, so one variant
carries them all with the class name to match on; the other cases are
the bridge's own. The alternative, a failure type per declaration file,
would be written by hand for every package and checked by nothing.
(user)
AM. The Python binder (session 8)#
AM1. renyi bind --python <package> [--module <name>] [--to
<directory>] writes a Python module of the project from the package
itself: the declaration file <directory>/<name>.ry (the module named
as the package when --module is left out) and the module's entry in
the manifest's python section (written when the manifest exists,
printed otherwise), through the interpreter of decision AL3 (the
manifest's, else RENYI_PYTHON, else the PATH) running an inspection
script that imports the package with the directory first on its module
path and reports its functions. The functions are the names of
__all__ that are functions when the package defines it, else the
public functions the module itself defines, in definition order; a
function's positional parameters are declared in order and required, a
default or not, *args and **kwargs are left out, a keyword-only
parameter with a default is left out and one without a default leaves
the function as a comment with the reason, as does a function whose
signature Python cannot give; a name becomes a Renyi name as a C name
does (snake case, a reserved word prefixed py_, a single letter
argument_<n>), a rename recorded in symbols; the purpose is the
docstring's first line as a sentence, else the signature as Python
prints it, cut to the line width. The four questions of 2026-10-07
and their answers: (i) the same command as the C binder, with
--python in place of the header, rather than a command of its own:
one place for "write me the declaration file"; (ii) the module name
defaults to the package name; (iii) every positional parameter declared
and required, since the bridge passes by position (AL2) and a Renyi
call names every argument anyway; leaving out the parameters with
defaults would hide them from the caller, and passing by keyword would
be a new protocol; (iv) __all__ first, the Python convention, so that
a package which says what it exports gets exactly that. (user)
AM2. The types the binder writes: int is Integer, float is
Float, str is Text, bool is Boolean, bytes is Bytes;
list[T], Sequence[T], MutableSequence[T] and Iterable[T] are
List of T, set[T], frozenset[T], AbstractSet[T] and
MutableSet[T] are Set of T, dict[str, T], Mapping[str, T] and
MutableMapping[str, T] are Map of Text to T, Optional[T], T |
None and Union[T, None] are maybe T, Annotated[T, ...] is what
T is, a bare list, set or dict is the same of JsonValue; a
result annotated None is no result; everything else, a missing
annotation included (Any, a class, a tuple, a union of two types, a
dict with other keys), is JsonValue of std.json at that position,
and the function carries a comment naming what stands as JsonValue.
The bridge carries what JSON carries (AL1), so the mapping stops where
JSON does; JsonValue keeps every function callable from the first
run, and the comment tells the editor where a record type would serve
better. The alternative, skipping a function whose annotation the
binder does not know (the C binder's rule), would drop most of a
typical package, whose functions are annotated partially or not at
all. (user)
AN. The resident world (session 8)#
AN1. The toolchain keeps a resident world of a project between
calls, in a crate of its own, renyi_workspace: the .ry files under
a directory and the files of the dependencies they import, each kept
with its text, its canonical layout, its syntax tree, the fingerprint
of its declarations and the check of every item of it. A refresh stats
the directory's files and reads again only those whose size or
modification time changed (and those stamped within two seconds of
their last write, since file systems round the time), formats and
parses again only those whose text changed, declares the world again
from the kept trees when anything changed, checks again only the items
whose canonical text changed (every item when the fingerprint of any
file changed, a file appeared, disappeared or stopped parsing, or the
manifest changed) and rebuilds the map from the result. What it gives
is what a fresh renyi index and renyi check give, byte for byte,
which a test holds on the corpus, the compiler, the starter pack and a
project taken through every kind of change. renyi mcp holds one; a
text may overlay a file (an editor's unsaved buffer). The owner's
four answers of 2026-10-07: (i) a file-level parse cache with
item-level rechecks rather than a whole-project rebuild or a
per-definition dependency graph: a body's check depends on the
project's declarations and on its own text and on nothing else, so an
unchanged body under unchanged declarations has the same check, moved
to where the item now sits; the fingerprint is the text of everything
a body elsewhere can see (the module's head, each function's signature
and docs, each type, ability and constant whole, each test's name,
needs and recording), so a change to a body costs one check and a
change to a signature costs them all, the cheap rule that is also
exact; (ii) a stat of the files on every call rather than a file
watcher: no thread, no platform notification API, the same answer on
every machine; (iii) a crate of its own rather than a part of
renyi_check or renyi_index: the checker and the index stay the
whole-project functions the self-hosted judges mirror, and the language
server, the watch of serve and the embedding API take the crate
without the binary; (iv) AN2. Measured on compiler/ (18 files, 23.6
thousand lines; a development build on Windows): the first
project_map call of renyi mcp 1.5 seconds, every later one 12
milliseconds, the map rendered each time. Closes open item R5-5 of
05-agent-tooling.md, which decision T4 had left at the file level.
(user)
AN2. The language server is a standard LSP server, renyi lsp, over
standard input and output, on the resident world of AN1: one
Workspace per workspace folder, the editor's unsaved buffers as
overlays. A protocol every editor speaks rather than a VS Code
extension of its own: the extension of decision AI2 gains a client of
a few lines, and every other editor gets the same server. It follows
AN1; the scope of its first version (diagnostics, hover with the
purpose and the signature, go to definition, document symbols) is
recorded with it. (user)
AN3. The server checks the files as written, not in canonical layout:
the workspace of AN1 has a mode for it (as_written), in which the
tree, the diagnostics and the map refer to each file's text on disk or
in its overlay, as renyi check reads it, and the map is built only
when asked for. The server publishes the diagnostics of every file of
the folder, open or not, as renyi check reports them (the layout's
included), after every change and only for the files whose diagnostics
changed; it synchronizes whole texts, counts positions in UTF-16 code
units (the protocol's default) and answers hover for a library
definition from the library's declaration files, with no location to go
to. The VS Code extension carries the client, bundled into one file at
release time, and the setting renyi.path names the binary. An
editor's positions must be those of the text in the buffer, which the
formatter would move; the map's hashes and line counts are a tool's
business, not the editor's, so the server never pays for them. Whole
texts rather than incremental changes: a file is parsed again whenever
it changed, so applying deltas would buy nothing but a second copy of
the text. Every file of the folder rather than the open ones: an error
a change causes in another file is the point of a project-wide check,
and the Problems panel is where it is seen. (derived)
AO. The watch of serve (session 8)#
serve (session 8)#The third of M5's four steps in the owner's order (2026-10-08). The owner's four answers, each the recommended option.
AO1. renyi serve [--watch] [options] <file.ry> [arguments]: without
--watch, renyi run; with it, the files of the program's project are
looked at every half second while no request is waiting, through a stat
by the resident world of AN1, and when one changed the program is
compiled again; when it checks clean, main is run again on the new
version between two requests, the listening socket kept open and handed
to the new program so that no request is lost, and the reload's message
names what the semantic diff found, a changed signature among the rest;
a version with errors is reported and the last good one keeps
serving. This replaces the mechanism Q4 described, the swap of the
changed definitions by content hash with a changed signature refused;
Q4's promise (the new code at the next request, no request lost,
nothing to migrate) stands. (i) Running main again rather than
patching definitions: a Renyi service has no state outside its request
(Q4's own argument), so a restart between requests is the swap with
nothing to migrate, and the VM keeps its program borrowed and compiled
to machine code whole; reference-counted code objects and a swap at
the next call (open item R7-3) are not needed. (ii) A clean check
rather than a refused signature change: the whole program is checked,
so a changed signature either fits every caller or the check fails;
what the diff finds is reported, not refused. (iii) A command of its
own rather than an option of run: run stays the one-shot command,
and serve reads as what a service is started with; run and test
refuse --watch. (iv) A poll of the resident world rather than a file
watcher, AN1's rule (ii) again: no thread, no platform API, the same
answer on every machine; a change to an unrelated file of the
directory costs one compile, which finds the program's sources
unchanged and reloads nothing. Closes R7-3 of 07-system-design.md.
(user)
AP. The embedding API (session 8)#
The fourth of M5's four steps in the owner's order (2026-10-08), which completes M5. The owner's four answers, each the recommended option, then the derived choices.
AP1. The embedding API is a Rust API first, renyi::Sandbox: a host
loads a module from a source file or a text with a renyi::Grant and
calls its public functions by name with Value arguments, the value or
the failure coming back; the grant is spelled as a needs clause is, in
a text or in a JSON file with the memory budget beside it ({"grant":
"console, network.http(\"host\") at most 60 per minute", "memory": "256
megabytes"}), and renyi run --sandbox grant.json runs main under the
same grant; the memory budget is a setting of the sandbox, not a clause
of the grammar, counted by a counting allocator as the bytes a call
holds above the level at its start, and a call that exceeds it fails as
a whole with OverMemory; every public function of the module is
callable, with the JSON Schema of those marked expose as tool beside
them. The C API of A5 is a layer over this one, for later; Python and
JS hosts go through it. (i) Rust first: the isolation and the grant are
the work, a language binding is a shell around them. (ii) The needs
syntax for the grant: one spelling for what a program may do, wherever
it is written, read by the language's own parser (parse_grant), so
budgets and guards come with it and nothing enters the frozen surface
(V11). (iii) A setting rather than at most 256 megabytes memory in the
grammar (open item R7-1, closed): the budget is the host's to set, not
the program's to declare; a counting allocator because the VM's values
are Rust allocations, so the allocator sees every byte, and the count
costs one load per allocation while no budget is in force. (iv) Every
public function rather than those with expose as tool: visibility is
the module's own word on what may be called, and the tool clause is
documentation for agents (D6), which the API reports beside it. (user)
AP2. A call whose needs the grant does not cover is refused before it
runs, as --deny refuses a program at start (E3); inside the call the
grant stack narrows as under run. The grant's budgets count across
the calls of one sandbox as one run; each call runs on a VM of its own,
and nothing else survives between calls. A budgeted run stays on the
interpreter, as a narrated or profiled one does (AG3), and the budget is
read at every call, primitive and loop turning. One budget is in force
at a time in a process, and it counts the process's allocations. The
official binary declares the counting allocator, renyi::Allocator
(mimalloc under the count), in src/main.rs rather than in the library,
so that a host keeps its own allocator and wraps it in renyi::Counting
when it wants the budget; a grant with memory is refused at load
without one. A bytecode file is refused by Sandbox::load, since it
carries no visibility; a format that does is a change to
compiler/bytecode.ry and the file, for later. renyi run --sandbox
refuses to start when main needs a capability the grant does not
cover, naming it; record and serve take the option too, and the
effective grant is what the manifest names. A refusal before the call
tells the host what the grant lacks in one message, where a boundary
failure would come back as the function's own failure type; the
interpreter alone because the safe points of the generated code are not
all the interpreter's, and a sandbox is about safety, not speed; the
allocator in the binary because a library that declares the global
allocator cannot be linked into a host that declares its own. (derived)
AQ. The profile-guided round on strings and JSON (session 9)#
AQ1. The first of the interspersed performance items the owner set on
2026-10-07 (the profile of decision AG5 on the two benchmarks the
positioning compares with CPython), done and measured: std.json
decodes without cloning the type's metadata per record and without
building the error-path strings of every item and field, and renders
text with no Json tree in between; the reader and the writer of
renyi_json copy runs of plain bytes at once; the one-character texts
of the ASCII range come from a table kept per thread; a compiled pattern
of std.regex and Text.matches is kept per thread; and an
interpolation joins its pieces where they lie on the stack. The round
began on the owner's machine (the profiles of perf on the release
build under WSL, about a thousand samples each) and was paused on
2026-10-08 with the change written as a script (commit 44763c4); session
9, the first in the cloud environment, applied it, ran the gates and
measured it. What the profiles said: on bench/strings.ry (a hundred
thousand pieces joined, 1.2 million characters counted) 40% of the time
in page faults, 19% in the interpreter loop, 11% under characters()
(an allocation per one-character text, a 29 MB vector grown by
doubling), 7% moving a primitive's arguments into the scratch buffer
(1.2 million calls of contains), 6% cloning and dropping values; on
bench/json_round_trip.ry (two thousand records rendered and read back
fifty times) 18% in decode, 13% in the error-path strings
"{path}[{index}]" and "{path}.{key}" made for every item and field
whether or not an error follows, 10% in the reader (from_utf8 once per
UTF-8 sequence), 6% in encode, 15% in the allocator, 5% cloning the
TypeMeta per record. The change, in five parts: (i) the decoder keeps
its position as a chain of borrowed segments (Path) rendered only for
a Mismatch or Constraint error, borrows the type's metadata and a
field's key under the exact naming (Cow), substitutes a field's type
only for a type with parameters, and parse no longer copies its
argument; (ii) the encoder walks a value once into a Sink: TreeSink
builds the Json tree encode returns (the recording,
http.post_json, server.ok_json and the Python bridge keep it) and
TextSink writes render's text with no tree in between, held equal to
write_json by a unit test on both layouts; the reader copies a run of
plain bytes at once and write_string the runs between escapes; (iii)
Value::character(c): the ASCII one-character texts from a per-thread
table, used by characters(), split("") and a loop over a text, the
list allocated once at its exact length; (iv) a compiled pattern cached
per thread (256 at most, then the cache is emptied), for std.regex and
Text.matches; (v) Vm::op_concat joins the pieces where they lie on
the stack, the text sized first, an Integer written straight into it.
Conformance case 54 (json_paths.ry) holds what these paths print: the
path of every Mismatch and Constraint error, the control characters
and the non-ASCII text of a document on both layouts, the three namings,
characters(), split(""), a loop over a text, every kind of value in
a hole, and a thousand matches of one pattern and three hundred of
different ones; its expected output was printed by the binary before the
change. Measured on 2026-10-08 in the cloud environment (Linux, four
cores, the release build with rustc 1.97.0, the two binaries from the
same tree with and without the change, cachegrind for the user-space
instructions and tools/bench.py --runs 5 back to back for the
wall-clock time): user-space instructions on strings 1.74 to 1.39
billion on machine code (-20%) and 1.97 to 1.62 billion on the
interpreter (-18%); on json_round_trip 2.34 to 1.00 billion (-57%) and
2.36 to 1.01 billion (-57%); on the compiler's self-check (checker.ry
on bodies.ry) 13.40 to 13.14 billion (-2.0%) and 13.12 to 12.84
billion (-2.1%). Wall-clock time, the best of five: strings 282 to 226
ms on machine code and 284 to 262 ms on the interpreter against
CPython's 106 ms; json_round_trip 314 to 126 ms and 303 to 125 ms
against 230 ms (from 0.7 to 1.8 times CPython's speed); the self-check
2895 to 2679 ms and 2572 to 2496 ms; primes, records and hello
unchanged within the noise of the machine, which moved a repeated
measurement by a tenth (CPython's own primes twin by a fifth between
the two rounds), so that a wall-clock difference under a tenth says
nothing here and the instruction counts are the measure, as in AG6. The
CI numbers of commit a2b0702 to beat were strings 179 ms and
json_round_trip 386 ms against CPython's 43 and 89 ms. Where the rest
goes, by cachegrind on the interpreter after the change: on strings,
40% in the interpreter loop (run_frames), 30% in the primitive
boundary once per character (call_primitive, the move of the arguments
into the scratch buffer, run_primitive, text_contains, the drops of
the arguments and of the drain, guarded, effect_of), 7% dropping and
4% cloning values, 5% the contains search itself, 3% iterator_next,
2% characters, 2% op_concat, the allocator under 2%; the page faults
of the 29 MB list of 1.2 million one-character texts, now one allocation
at its exact length, are kernel time that no instruction count shows,
which is why the interpreter's wall-clock gain is smaller than its
instruction gain. On json_round_trip, 21% in the reader (string,
value, expect), 8.5% in write_string, 8% in decode_at, 4% in
walk, 7% growing vectors and texts, 9% in the allocator, 5% in the
interpreter loop, 2% parsing Integers, 3% in the keys (Naming::key,
TextSink::key), 1% finding a field by name among the object's entries:
the plain cost of reading and writing the format. Not done, on purpose:
Text stays Rc<str> (decision X3), so change out to "{out}{piece}"
in compiler/ still copies the accumulated text per piece; the pure
primitive boundary stays as AG6 left it (the move of the arguments into
the scratch buffer, 1.2 million times on strings, is the next item);
Text.matches is not on the compiler's path (three calls in
project.ry and refine.ry), so the cache changes nothing for the
self-check. Against the targets the owner named with the item (strings
and JSON at CPython's speed, the compiler's self-check twice as fast):
JSON is past CPython (1.8 times its speed here, from 0.7); strings
stands at half of CPython's speed (from four tenths), with the loop and
the primitive boundary per character left, which are the baseline JIT's
to take out; the self-check moved by two percent, as AG6 foresaw, since
its time is in the value operations of the interpreter, not in strings
or JSON. What follows, in the owner's order: the baseline JIT (AG5, item
iii), then the showcase application. (user)
AR. The baseline JIT (session 9)#
AR1. The baseline JIT of decision AG5 (iii) is built in this order,
each step measured and kept by the rule of AG6 (the measure is the
compiler's self-check, compiler/checker.ry on compiler/bodies.ry, by
its count of user-space instructions on the interpreter and on machine
code, with bench/records.ry and four micro-benchmarks beside it; a
step stays when it cuts the self-check's instructions, and the round
ends when a step brings under 2% or the self-check runs twice as fast as
AG6 left it): (i) fused operations in the bytecode itself, LoadField
first (a field of a local, read in its slot), so that both tiers gain
and the interpreter's look at the next op (AG6) goes; (ii) direct calls
between generated functions, with the parameters and the result the
checker types as Integer, Boolean or Float passed in registers, the
frame still pushed on the VM's frames for the handlers, the grant and
the hand-back; (iii) the layout of Value pinned (repr(C)), so that
the generated code clones, drops, loads, stores and reads fields inline,
with the slow paths as helpers. The owner's four answers of
2026-10-08, asked after the round of AQ with the micro-benchmarks of the
two tiers in hand (instructions per turn of a loop, cachegrind, the
release build; machine code against the interpreter): a call with an
Integer parameter 668 against 1133; a field of a local 1043 against 818;
a call with a record parameter that reads a field of it 1535 against
1183; a record built and a field of it read 1357 against 1480. The
machine code of AG1 does for a boxed value what the interpreter does,
through a helper per op on the VM's stack, so it loses on the operations
ordinary programs are made of, where AG6's interpreter reads a field in
the slot and the helper boundary clones and drops the holder; the
self-check gains nothing from it (AG5). Step (iii) was the owner's
choice over the two steps the session recommended (the fusions and the
calling convention first, the layout only after a profile of what
remained): the ceiling of the helper-call design is the interpreter's
own speed less the dispatch, and the self-check's time is in the clone,
the drop and the stack traffic (AG5), which only inline code reaches.
Fused operations in the bytecode rather than in the code generator
alone, the question AG6 had left as a format question (Z1): the
interpreter is the reference and most of what runs, and a fusion both
tiers share is one rule in the two emitters instead of a look at the
next op in the loop; the format number moves with each addition (Z2).
(user)
AR2. Stage 1 of AR1, done and measured: Op::LoadField { slot, name,
site } is Load(slot) followed by Field { name, site }, the field of
a local read in its slot, so that the holder is neither cloned nor
dropped; both emitters emit it for x.field and self.field on a local
that is not a move receiver and for the field of a variant pattern, the
interpreter's look at the next op (AG6) is gone, the generated code
calls one helper where it called two, and the bytecode file is format
4. In the compiler written in Renyi, 3,859 of the 4,480 Field ops
follow a Load (static), and on the self-check Load was 29% and
Field 6% of 101 million ops run. Measured as AR1 says (cachegrind,
the release build, the binary of commit 2fcab99 against the stage): the
self-check 13.14 to 12.51 billion instructions on machine code (-4.7%)
and 12.84 to 12.63 billion on the interpreter (-1.6%);
bench/records.ry 571 to 516 million (-9.7%) and 655 to 653 million
(-0.3%); per turn of the micro-benchmarks, machine code then the
interpreter: the field of a local 1043 to 902 and 818 to 811, the call
with a record parameter 1535 to 1394 and 1183 to 1161, the record built
and read 1357 to 1216 and 1480 to 1464, the call with an Integer
parameter 668 unchanged and 1133 to 1104 (the look at the next op that
every Load paid). The step stays by the rule. The profiler's report
has a table of operation pairs since this stage (operations by pair,
the kinds run one after the other in one code object), which is how the
next fused operations are chosen; on the self-check after LoadField
the pairs that remain are Load Load 6.1 million, Load Call 6.0,
Load Const 4.7 and Const Binary 4.7, Store Load 3.8, JumpIfFalse
Load 3.0, Binary JumpIfFalse 2.4, Store LoadField 2.1, Binary
Store 1.6, Dup JumpIfTrue and Binary Dup 1.6 (the short circuit of
or), Load IsVariant and IsVariant JumpIfFalse 1.1 (the dispatch of
a match), of 96 million; the pairs across a statement's end (Store
Load, JumpIfFalse Load, Store Jump) fuse nothing, and each of the
others saves a dispatch and a push or a pop, about a percent of the
self-check apiece by the rule of thumb of 30 to 40 instructions per op
saved, which is under the 2% a step must bring: the fusions stop here
and the round goes on to stage 2. (user)
AR3. Stage 2 of AR1, done and measured: a generated function calls a
compiled callee's body directly, its Integer, Boolean and Float
arguments and result in registers, through a second function per code
object. Every code object now compiles to two Cranelift functions: the
body (renyi_direct_*), whose signature is the VM, the frame's base,
the pc to enter at, whether a direct call entered, then the typed
parameters in slot order, and which returns a status (D_RETURNED with
the bits of a typed result; D_BOXED or D_FAILURE with the value on
the caller's stack; D_DEOPT, D_INTERRUPT, D_STAY) beside the bits;
and the trampoline (renyi_code_*), with the Entry signature the VM
calls as before, which at the start takes the typed parameters from the
frame's slots under the checks the prologue used to make (a parameter
that does not fit hands the frame back), at a loop header passes zeros
for the body to overwrite from the slots, and maps the body's status to
the entry's; the body leaves a typed result in a register only for a
direct caller, and on the stack as before for a trampoline's, so that a
call from the interpreter costs what it cost. A call site to a declared
function with a code object loads the callee's body from a table the JIT
keeps by code object (filled when the code is compiled), asks
rt_direct_entry when the table has none yet (the callee is compiled
when it is hot enough), and goes through rt_call as before when there
is none or when the count of generated frames on the machine stack,
which the generated code reads and moves in place by its address in the
JIT, is at DEPTH_LIMIT; else it boxes the operands of the boxed
parameters onto the stack where they lie, has rt_direct_frame push the
callee's frame (the boxed arguments moved into their slots by a mask of
the parameters, the others Nothing until a hand-back writes the
registers into them), and calls the body with the typed operands from
its registers. A typed result comes back in a register and a boxed one
on the stack, both handled in place; a failure, a frame handed to the
interpreter (run to its end) and an interrupt (its frame abandoned) go
through rt_direct_after, which leaves what rt_call would. A site is
direct only when every typed parameter has a typed operand in the
caller; the analysis holds a parameter's slot to the kind its declared
type gives it (a function that stores another kind into the slot stays
with the interpreter), so that the caller derives the callee's signature
from the function's declared types alone and a callee compiled later
fits. The return of a typed result of the declared kind leaves the frame
without a push (rt_leave_typed); a boxed value where the declared
result is typed is unboxed on the way out when it fits
(rt_leave_unbox), else returned boxed. On the self-check with every
code object compiled, all 555 compile (the analysis rule rejects none),
5.23 million calls go from generated code and none to the interpreter;
with the default tiering 112 compile and 126 thousand of 4.1 million
calls reach the interpreter (cold callees). Measured as AR1 says,
against the binary of stage 1: the self-check 12.51 to 12.32 billion
instructions on machine code (-1.5%) and 12.63 to 12.91 billion on the
interpreter (+2.2%, whose loop the stage does not touch: the code layout
of the binary, which AG6 saw move the loop by up to 3%);
bench/records.ry 516 to 518 million on machine code; per turn of the
micro-benchmarks on machine code: a call with an Integer parameter whose
argument is in a register (a literal loop bound; a bound read from the
arguments is a maybe Integer, boxed, and its loop variable with it)
542 to 305 (-44%), the same call with a boxed argument, through
rt_call and the trampoline, 668 to 719 (+8%: the trampoline's own call
and the status mapped), the call with a record parameter 1394 to 1236
(-11%), the field of a local and the record built unchanged. The step
cuts the self-check and stays; it brings under the 2% at which AR1's
rule ends the round, but the layout inlining of stage 3 is what the
owner chose the round for and the register convention is its ground, so
the session goes on to stage 3 and leaves the question to the owner, who
reads this entry first. What the profile of the self-check on machine
code says after the stage: the frame protocol (rt_direct_frame 3.4%,
the locals' resize 2.1%, leave_frame 1.9%, frame_grant 1.2%) and the
primitive boundary (status 3.5%, call_from_stack 2.6%,
call_primitive 2.2%, the argument move 2.1%) are the next largest
items after the clone (4.1%) and the drop (6.9%) of values and the
interpreter's own run of main and the cold code (7.8%). (user)
AR4. Stage 3 of AR1, done and measured: the layout of Value and of
Int is pinned (repr(C, u8)), the VM's stack, frames, handlers and
field-site cache and the fields of a record and of a variant are pinned
vectors (Pinned<T>: the pointer, the length and the capacity, in that
order), and the generated code does the value operations, the frame
protocol of a direct call and the field read in place, a helper left
only for each slow path. The constants of the layout live in
value::layout and a unit test holds them to the types: the tag at
offset 0 in declaration order, the payload at 8; an Rc payload points
at its allocation, whose first word is the strong count (an Rc<str>
and an Rc<[u8]> are fat pointers whose address is the allocation too);
an Integer holds its Int with the small-or-big tag at 8 and the
payload at 16; the thirteen tags with an Rc payload are one mask
(RC_TAGS); a Record and a Variant lie sixteen bytes into their
allocation, the type, the tag and the field vector at fixed offsets.
Three sub-stages, each measured as AR1 says (the binary before against
the binary after, cachegrind, the release build). (3a and 3b) The
pinned layouts, then Load, LoadMove, Store, Pop, Dup, Const
and Nothing on a boxed value in place: the clone is the three words
copied and the strong count incremented when the tag is in the mask or
the Integer is big, the drop the count decremented and rt_drop_at when
it was one, a push past the capacity rt_grow; the top of the stack is
boxed (push_typed_value) and unboxed (the tags read, the value that
does not fit stays for the interpreter as before, a non-Boolean
condition crashes through rt_take_bool) in place, and IsNothing,
IsFailure, JumpIfAbsent and JumpIfFailure read the tag. The
self-check 12.32 to 12.10 billion instructions on machine code (-1.8%)
and 12.91 to 12.90 on the interpreter; bench/records.ry 518 to 459
million (-11.5%) and 663 to 658; per turn of the micro-benchmarks on
machine code: the typed call 305 to 311, the call with a boxed argument
719 to 633, the field of a local 901 to 731, the record call 1236 to
1055, the record built and read 1215 to 1109. (3c) The frame of a direct
call pushed in place (the boxed arguments moved to their parameters'
slots by the mask, which is static, every other local's tag written
Nothing, the record written with the caller's grant when the callee
narrows nothing, else the grant from rt_frame_grant; rt_room and
rt_grow_frames for the capacities; the count of calls kept), and every
return leaves the frame in place: the boxed locals and the boxed
operands under the result released inline up to RELEASES_INLINE of
them, else through rt_truncate, the handlers cut to the frame's
height, the frame popped, a boxed result moved to the frame's first
slot, a typed one back in a register to a direct caller and boxed on the
stack to a trampoline's, the unbox on the way out of AR3 by the tags;
rt_direct_frame, rt_leave_*, rt_return_* and
Vm::push_frame_direct are gone. The self-check 12.10 to 11.69 billion
(-3.4%) and 12.90 to 12.94 on the interpreter; bench/records.ry 459 to
464 million (+1.1%); per turn: the typed call 311 to 119 (-62%), the
boxed call 633 to 587, the record call 1055 to 873, the field and the
record built unchanged. (3d) LoadField reads the site's cache entry
and the holder's tag in place: a record or a variant of the cached type
with the cached tag and the index in range gives its field copied with
one more reference, anything else goes through rt_load_field, which
fills the cache as before; and the pinned vector's insert, extend,
split_off and resize work on the three words instead of going
through a Vec. As first written, with a path per holder and a push
that checked the capacity each time, the step measured the self-check
11.69 to 11.70 billion (+0.1%) while bench/records.ry fell 464 to 429
million (-7.5%) and, per turn, the field of a local 730 to 648, the
record call 873 to 790, the record built 1109 to 1005: the IR had grown
from 131 to 236 thousand Cranelift instructions in 19 to 34 thousand
blocks since 3b, and Cranelift's own work from 5.6% to 12.5% of the
self-check, which ate the run-time gain. The IR made compact (the
reference-count test one branch, both payload words read and one
selected; the stack's capacity checked once in the prologue for the
frame's locals and its deepest operand stack, so that no push checks;
one path for a record and a variant in the field read, the type at one
offset in both and the rest selected; four releases in place at a
return, else rt_truncate): the self-check 11.69 to 11.66 billion
(-0.25%), the interpreter 12.94 to 12.90, bench/records.ry 464 to 437
million (-5.8%), per turn the typed call 119 to 131, the boxed call 587
to 605, the field of a local 730 to 677, the record call 873 to 849, the
record built 1109 to 1041 (the first form's 648, 790 and 1005 were lower
per turn: the test without branches and the selected path cost
instructions at run time that the compile time pays back on the
self-check); the IR 200 thousand Cranelift instructions in 15 thousand
blocks, Cranelift's own work 10.3% of the self-check and the generated
code's 16.6%. The stage as a whole, against the binary of stage 2: the
self-check 12.32 to 11.66 billion (-5.4%), the interpreter 12.91 to
12.90, bench/records.ry 518 to 437 million (-15.6%); the round so far,
against the binary AQ left: the self-check 13.14 to 11.66 billion
(-11.3%). Each sub-stage cut the self-check and stays by the rule, 3b
and 3d under the 2% at which AR1 ends the round, so the round's end is
the owner's call, with this in hand: Cranelift's compile time is now a
cost every inline sequence pays at each of the 112 compilations, and a
cheaper register allocator does not pay (single_pass halves
Cranelift's time, 658 to 339 ms on the self-check, and loses more in the
code: the self-check +4.2%, bench/records.ry +11%, the record call per
turn 789 to 1025; RENYI_NATIVE_REGALLOC keeps the comparison as a
development aid); what remains on the self-check's profile after the
stage: the generated code 16.6%, the interpreter's run_frames 8.7%
(main and the 443 code objects called but cold under HOT_FACTOR),
Cranelift and regalloc2 10.3%, the drop glue 5.1% and Value::clone
2.2% in the helpers and the primitives, the primitive boundary
(call_from_stack 3.0%, status 2.9%, call_primitive 2.4%,
run_primitive 1.3%), the boxed binary operations (binary_values and
rt_binary 1.8% each), the interpreter's push_frame_in_place 1.7% for
the cold callees, Value::eq 1.7% and mimalloc about 3%. (user)
AR5. The tiering of the cold code, the owner's choice for the round's
next step (2026-10-08): HOT_FACTOR is 8000, where it was 2000, and the
loop-header entry keeps the same factor as a call. The measure is
AR1's (the self-check's instructions, cachegrind, the release build of
stage 3; RENYI_NATIVE_HOT sets the factor for one run, so one binary
measured every value). The factor swept: 500 gives 13.15 billion
instructions (205 code objects compiled, 9,676 ops, Cranelift 1.1
seconds), 1000 12.09 (149 compiled), 2000 11.66 (112 compiled, 4,703
ops), 4000 11.24 (77 compiled), 6000 11.16 (62 compiled), 8000 11.13 (51
compiled, 1,477 ops, Cranelift 146 ms), 12000 11.23 (40 compiled), 16000
11.39 (38 compiled), 32000 11.78 (23 compiled): Cranelift's own work is
proportional to the size of what it compiles, about a quarter of a
million instructions per op (the IR is 42 Cranelift instructions per op
and each costs about 6,000 to compile), while a compiled op saves the
interpreter's dispatch and boxing, a few tens of instructions each time
it runs, so a code object pays for its compilation only after some ten
thousand runs of each of its ops; the 443 code objects called but cold
under 2000 ran about a billion instructions in the interpreter, and
compiling them would have cost three. bench/records.ry goes the other
way, 433 million at 500, 437 at 2000, 442 at 4000, 451 at 8000, 469 at
16000: a short program with one hot loop wants that loop compiled at
once and nothing else, and every doubling of the factor is more turns
interpreted before the entry at the loop header. A second factor for
that entry, so that a running loop compiles sooner than a function that
is called (LOOP_FACTOR 500, RENYI_NATIVE_HOT_LOOP), was built and
measured: with the call factor at 2000 the self-check rose from 11.66 to
12.05 billion (137 compiled: the loops of twenty-five more code objects,
whose turns did not pay for them), with 4000 from 11.24 to 11.77 and
with 8000 from 11.13 to 11.67; the mechanism is not kept, and
bench/records.ry pays the 3.2% (437 to 451 million) for the
self-check's 4.5% (11.66 to 11.13 billion), by the rule. What a better
rule would need is a prediction of the runs to come, which a count of
the runs so far does not give; the shape to try next, if the round goes
on, is a cheaper compilation for the first tier (an IR without the
inline sequences of AR4 for a code object that just became warm, the
full one when it stays hot), so that the cost of being wrong about a
function falls instead of the threshold rising. (user)
AR6. The baseline JIT's round ends (the owner's answer of 2026-10-08),
with the machine code doing the value operations, the frame protocol and
the field read in place and the tiering at 8000. The round against the
binary AQ left: the compiler's self-check 13.14 to 11.13 billion
instructions on machine code (-15.3%) and 12.84 to 12.90 on the
interpreter (+0.5%, the code layout of AR3); bench/records.ry 571 to
451 million (-21%) and 655 to 654 on the interpreter; per turn of the
micro-benchmarks on machine code, the typed call 668 to 130 (-81%; 605
with a boxed argument), the field of a local 1043 to 677 (-35%), the
call with a record argument 1535 to 849 (-45%), the record built and
read 1357 to 1041 (-23%), the interpreter's per turn up 2 to 3% with the
layout. AR1's rule had ended the round twice (AR3, AR4) before the owner
did; what the profile leaves is in AR5 and the handoff: the generated
code itself (16.6% of the self-check), the cold code in the interpreter
(8.7%), the primitive boundary (about 9%), Cranelift's compile time
(half of what it was under 2000), the clone and the drop in the helpers
and the primitives (about 7%); the shape to try first in a later round
is the cheaper first tier of AR5. The owner's other answers of the day:
the measure stays the self-check's total instructions, compile time
included; the micro-benchmarks live in bench/micro/ with
tools/measure_native.sh; stage 3d stays in its compact form. (user)
AS. renyi build (session 9)#
renyi build (session 9)#AS1. renyi build writes an image file, .ryi: the program's
bytecode with the machine code of every code object, which run,
record, test and reproduce take in place of a .ry or a .ryc
and run without compiling; build --exe, a second step, copies the
renyi binary and appends the image, the self-contained executable of
A1. The generated code holds no address: every helper, the table of
compiled bodies, the counters and the constants are reached through the
VM pointer, so the image is a plain block of bytes placed in executable
memory at load, with a header naming the renyi version, the format of
the generated code and the target with its CPU features; a mismatch
refuses the image with a diagnostic whose fix is to build again. build
compiles every code object the analysis accepts (the rest stays
bytecode, as in a run), at the optimisation level the self-check
measures best once compile time is no longer paid at run time; the JIT
uses the same address-free code. The owner's four answers of
2026-10-08, after the baseline JIT's round closed (AR6) with the
wall-clock picture of the release build on this machine: primes 64 ms
(CPython 587), strings 133 (84), records 66 (218), json_round_trip
98 (161), the self-check 1963 ms on machine code and 1918 on the
interpreter, from 2759 and 2025 before the two rounds; machine code now
wins on ordinary programs, which AG5 made the condition for the image.
What an image removes is the cost that remains in every run: Cranelift's
compilation (five percent of the self-check at HOT_FACTOR 8000, and
most of a short program's time), the warm-up during which a program runs
on the interpreter before its code is hot (primes lost twelve
milliseconds to the raised factor of AR5), and the cold code the tiering
leaves to the interpreter (nine percent of the self-check), while a
build-time compilation can afford Cranelift's optimising level, which a
run cannot. The alternatives not taken: the machine code as a section of
the .ryc JSON (one format, but a large file and a slow load for what
is a binary artifact); object files with relocations through
cranelift-object and a loader of ours, or a native executable through
the system linker (a C toolchain on the user's machine, against H1's one
binary); only the hot code objects of a recorded run (a smaller image
for one more step); a silent fall-back to the bytecode on a mismatch (a
run that is quietly slower is the failure mode the language refuses
elsewhere). The address-free form costs an indirect call per helper and
a load per constant, measured by AR1's rule as the first stage; it also
frees the JIT from cranelift-jit: the code is compiled by Cranelift's
context alone and placed by the VM. (user)
AS2. Stage A of AS1, done and measured: the generated code holds no
address. Every helper is called through the VM's table of helpers
(NativeState::helpers, in the order of codegen::SIGNATURES), the
table of compiled bodies, the count of generated frames and the count of
calls are read through the VM (NativeState::direct_table, depth,
calls), a constant is read through the VM's table of each code
object's constants, and the trampoline reaches its body through the
table of bodies; the code is compiled by Cranelift's context alone,
refused when it carries a relocation (none does: the 555 code objects of
the compiler compile), and placed by the VM in executable memory it
protects itself (CodeArena: fresh pages per function, written, flushed
from the instruction cache and made executable once, as cranelift-jit
did, through region and the icache crate it used), so cranelift-jit
and cranelift-module are gone from the dependencies. Measured as AR1
says against the binary of AR5 (cachegrind, the release build, the
same hotness factor): the self-check 11.13 to 11.18 billion instructions
on machine code (+0.46%) and 12.90 to 12.96 on the interpreter (+0.45%,
the code layout); bench/records.ry 451 to 452 million (+0.15%); per
turn of the micro-benchmarks the typed call 130 to 135, the boxed call
605 to 603, the field 677, the record call 849 to 853, the record built
1041 to 1040. The half of a percent is the indirect call in place of a
direct one, the load of a table's pointer and the two loads a constant
takes, and it is the price of an image that needs no relocation (AS1);
the step stays by the owner's decision, not by AR1's rule, which it
fails by that half percent. (user)
AS3. Stage B of AS1, done and measured: the image file .ryi and
renyi build, which compiles every code object at Cranelift's speed
level unless --opt none is asked. The file: the magic, the image
format, a header (the renyi version, the code format the generated
code assumes of the VM, the target with every CPU feature Cranelift
detected, the optimisation level), the bytecode as the .ryc text, and
per code object the body, the trampoline, the loop headers and the deopt
points, or a mark for one the analysis left to the interpreter
(native/image.rs; the writer, the reader and a round-trip test).
run, record, test and reproduce take it in place of a source:
the program comes from the embedded bytecode, the manifest's code hash
is the bytecode's as for a .ryc, and the VM's JIT places the code of
every object in one allocation and marks it ready, so nothing compiles
at run time and no code object is cold. A header that names another
renyi, another code format or another target is refused with the
message naming both sides and the fix, to build again; equality of the
feature set is the rule (an image built on an older processor would run
on a newer one and is refused all the same; a portable image is a later
question). Measured as AR1 says on the release build: the compiler's
self-check 11.18 billion instructions on the JIT run, 9.23 as an image
at none (-17.5%) and 9.07 at speed (-18.9%); bench/records.ry 452
million on the JIT run, 423 and 418 as images; the compiler's image is
17.6 MB for 955 code objects and builds in 3.7 and 4.4 seconds. speed
is the default by AR1's rule since a build pays the compile time once,
and none stays available for a build that must be quick or must match
the JIT's code exactly. What the round's measurements also showed, with
cachegrind's cache simulation on the self-check: the machine code runs
14% fewer instructions than the interpreter and misses the first-level
instruction cache ten times as often (105 million misses against 10),
which is why the two tiers tie in wall-clock (about 1.9 seconds each)
despite the count; the generated code is large (18 KB a code object),
and its size, not its instruction count, is the lever the next
performance round pulls first. (user)
AS4. Stage C of AS1, done: renyi build --exe writes the
self-contained executable of A1, this renyi binary copied with the
image appended and a trailer of 24 bytes (the image's offset, its
length, the magic RENYIEXE); at startup the binary reads its own last
24 bytes and, when the trailer is there, runs the image with its whole
command line as the program's arguments, before any command of renyi
is read. The default name is the program's stem (.exe on Windows);
the file is made executable on Unix and signed ad hoc on macOS when
codesign is at hand, the command being the message otherwise. The
reasons: no linker and no C toolchain, by H1's one binary, so that
build --exe works wherever build does and ships nothing new; the
trailer at the end rather than a section inside the binary, because
bytes appended to an ELF, a Mach-O or a PE leave it an executable the
loader accepts unchanged, while a section means a format-aware rewrite
per platform; the check at startup, one open and one read of 24 bytes
of the binary's own file, is what every command of renyi pays for it.
What the executable is not: smaller than the toolchain (the whole binary
comes first, its commands unreachable rather than removed: the
compiler's executable is 35 MB, the binary and its image), compressed
(a decompression at every start, for a file the page cache serves), a
wrapper for a .ryi already built (build --exe builds from the
sources or the bytecode, as build does, so that one command does the
whole job; a stub binary without the toolchain would be a second
artifact to build and ship), or portable beyond the image's own rule
(the same renyi, code format and CPU features; a mismatch is refused
at startup with the same message and the same fix). Measured on the
quiet machine, the best of five runs, as the closing wall-clock picture
of the round the image ends: the compiler's self-check 1841 ms on the
JIT run, 1950 on the interpreter, 1691 as an image at none and 1511
at speed (-18% against the JIT run, the compile time, the warm-up and
the cold code gone); bench/records.ry 62 ms on the JIT run, 54 as an
image at either level; bench/primes.ry 42 and 35; hello 10 and 11
(the load of 235 KB of code for thirteen code objects costs a short
program a millisecond: an image is for a program that runs long enough
to compile). The executable runs as its image does. The cache
simulation also settled the question AS3 left open about the level:
Cranelift's speed_and_size generates the same code as speed within
nine bytes (17,455,606 against 17,455,597) with the same first-level
instruction-cache misses (158.0 million on the self-check), so the size
of the generated code is a question for the sequences codegen.rs
emits, not for Cranelift's level. (user)
AT. The size of the generated code (session 9)#
AT1. A round on the size of the generated code, measured by
KCachegrind's estimate of the cycles over cachegrind's counts on the
compiler's self-check: Ir + 10 (I1 misses + D1 misses) + 10
conditional mispredicts + 20 indirect mispredicts + 100 LL misses,
deterministic, on the JIT run, the interpreter and the image, with the
wall-clock reported at the end of each stage (tools/measure_size.sh);
a change is kept when the estimate of the JIT run falls. The order: the
cuts that cost no instruction first (AT2), then the bytecode of the
image in a binary encoding (the .ryc stays JSON, decision Z1
unchanged), then the reference-count sequences as shared stubs if the
rule keeps them; the record's layout gains a tag word so that a record
and a variant share the prefix the field read reads. The owner's four
answers of 2026-10-08, after renyi build closed (AS4). The census of
the compiler's image (tools/image_census.py) that opened the round:
17.5 MB, of which 9.0 MB is the bytecode as JSON text and 8.3 MB the
machine code of 955 code objects, 46,193 ops, 179 bytes of body per op
and 8.7 KB per code object; a least-squares attribution over the code
objects (r² 0.98) charges LoadField 462 bytes each (22% of the
bodies), Load 173 (21%), Call 440 (21%), Store 171 (11%),
Const 148 (7%), Return 223 and ReturnNothing 363 (10% together),
a deopt point 384 (4%). The measurements of AS3 and AS4 said why the
size matters: the machine code runs 14% fewer instructions than the
interpreter on the self-check and misses the first-level instruction
cache ten times as often, and Cranelift's speed_and_size level changes
nothing, so the lever is in the sequences codegen.rs emits. Why the
estimate rather than AR1's instruction count: a sequence replaced by a
call to a shared stub costs instructions and saves bytes, the trade this
round exists to make, and the count alone would refuse every such step;
why not the wall-clock alone: its noise on this machine (about 3% on a
two-second run) hides the steps, so the estimate decides and the
wall-clock confirms the stage; why KCachegrind's weights and not ours:
they are the published ones and the point is a stable, deterministic
rule, not a model of this processor. Why the image's bytecode in a
binary encoding belongs to the round: loading the compiler's image costs
152 ms against 172 ms for compiling the compiler from source, almost all
of it the parse of 9 MB of JSON, so the image barely starts faster than
the source, which its size hides; the .ryc stays JSON because it is
read by people and written by the compiler in Renyi. Why the record's
tag word: the field read's fast path selected between the record's and
the variant's offsets twice and checked the index against the length;
with {ty, tag, fields} at the same offsets in both (a record's tag is
usize::MAX, as the field cache already has it) one path serves both,
and a hit needs no range check because the index was cached from a
holder of the same type and tag; eight bytes more per record is the
price, accepted. The starting point, the binary of AS4 (71965aa): the self-check on the JIT run 11.18
billion instructions, 116.6 million first-level instruction misses,
75.1 million data misses, 2.17 million last-level misses, 35.4 million
conditional and 85.0 million indirect mispredicts, 15.37 billion
estimated cycles; on the interpreter 12.96 billion instructions, 12.0
million instruction misses and 185.3 million indirect mispredicts (the
dispatch), 18.01 billion; as an image at speed 9.07 billion
instructions, 160.2 million instruction misses, 12.63 billion. What
the indirect mispredicts say: the interpreter's dispatch costs it 3.7
billion of its estimate, and the generated code's calls of helpers
through the table 1.7 billion of its own, a tenth. (user)
AT2. Stage 1 of AT1, done and measured: the cuts that cost no
instruction. The callee's prologue writes Nothing to every local that
is not a boxed parameter, once per callee, where the frame push of a
direct call wrote them at every call site; the field read's fast path
reads a record and a variant on one path through the shared prefix
{ty, tag, fields} (the record's tag word is usize::MAX) and drops the
range check, which a cached index of the same type and tag does not
need; the guards of one op that reach it with the same operand state
share one block that hands the frame to the interpreter (the three paths
of a call's result shared theirs); the direct call no longer asks the
JIT for a body the table lacks (the call goes through the interpreter,
which compiles a hot callee on the way and enters it through its
trampoline, and the next call finds the table filled); and the count of
calls from generated code is gone from the state and the report. The
code format is 2. Measured by AT1's rule against the binary of AS4:
the self-check on the JIT run 15.37 to 15.13 billion estimated
cycles (-1.6%: 11.18 to 11.02 billion instructions, 116.6 to 106.4
million instruction misses), on the interpreter 18.01 to 17.96 (-0.3%),
as an image 12.63 to 12.42 (-1.7%: 9.07 to 8.88 billion instructions,
160.2 to 155.6 million misses); the compiler's machine code 8.26 to
7.83 MB (-5.2%; 179 to 170 bytes of body per op, 825 to 709 deopt
points), its image 17.46 to 17.02 MB. The cuts that moved the
instruction count were the field read's (the two selects, a load and a
compare per hit), the call counter's (three per call) and the ask
path's; the locals written by the callee moved bytes, not
instructions. (user)
AT3. Stage 2 of AT1, done and measured: the image carries the
program in a binary encoding (crates/renyi_vm/src/binary.rs: an
integer LEB128, a text its length then its bytes, an option one byte
then the value, a list its count then its items, a variant one byte
then its fields, the maps in key order; the same content as the
bytecode file, written in the order file.rs writes it, checked on
loading as the file is) together with the hash of the program's
bytecode file, which the run manifest names as the code hash, so that
a recording made from the .ryc reproduces against the image and the
other way round. The .ryc stays the JSON of Z1. The image format is
2. Why an encoding of the program and not of the JSON tree: the parse
of the text was only part of the load; the tree's million small
strings (every number is one) and the lookups by key were the rest, and
an encoding read straight into the program skips both. Why the hash is
stored rather than recomputed: rendering the JSON at load would cost
what the encoding saves. Why not the .ryc itself in binary: it is
read by people and written by the compiler in Renyi too (Z3), and an
image is written by renyi build alone. The census tool takes the
bytecode file beside the image for the ops, since the image no longer
holds them as text. Measured: the compiler's image 17.02 to 8.71 MB (the program
8.99 MB of JSON to 0.68 MB), its load 152 to 69 ms, against 166 ms for
compiling the compiler from source and 165 for reading its .ryc
(renyi run <file> /nonexistent, which fails before main); the
self-check as an image 12.42 to 11.37 billion estimated cycles (-8.4%:
8.88 to 8.13 billion instructions, the parse of the JSON gone), the JIT
run and the interpreter within the noise of the binary's own layout
(+0.1% and -0.3%, the generated code untouched); hello as an image 42
KB in place of 235 and 7 ms in place of 8 for the source, the image
faster than the source now on the shortest program too; in wall-clock
the self-check 1448 ms as an image against 1723 on the JIT run, the
best of five each. (user)
AT4. Stage 3a of AT1, done and measured: the stack's height is static
in the generated code and the frame pointer stays in a register. At
every op the frame's part of the stack is its locals and the boxed
operands of the abstract state (a typed operand is in a register), so
the stack's length is the frame's base plus a constant the code
generator knows; the generated code computes it instead of loading it
from the VM and stores it where a helper or the interpreter reads it
(height, length_at, store_height), and addresses every slot and
operand from one register that holds the stack's pointer plus the
base, read once at the entry and again after every call out of the
generated code, which alone can move the stack (frame_var,
reload_frame, address_at, top_address, last_address). The
owner's order of 2026-10-08 for the round's third stage: these two
cuts first, then the shared stubs, each by the rule. Why they cost
nothing: a load, a multiply and two additions per stack access become
an addressing mode of the load or store that follows, and the one load
of the pointer per op becomes one per helper call; the invariant they
rest on, that the real stack and the abstract state agree at every op,
is the one the room check of AR4 already rested on (the deepest operand
stack of a body is read off the states). The one subtlety: after a
result is popped from the state but left on the stack (a boxed return,
IsNothing), the value lies at the state's height, not below it, and
the generator says so where it reads it. Measured by AT1's rule against
the binary of AT3: the self-check on the JIT run 15.15
to 14.92 billion estimated cycles (-1.5%: 11.02 to 10.87 billion
instructions, 108.8 to 102.2 million instruction misses), as an image
11.37 to 11.15 (-2.0%: 8.13 to 7.99 billion instructions, 151.2 to
142.6 million misses), the interpreter unchanged (17.90 billion); the
compiler's machine code 7.83 to 7.91 MB (+1.0%: the frame pointer's
reload after every helper call and its block parameters at the merges
outweigh the address arithmetic folded away, while the instructions and
the misses fell, which is what the rule weighs); in wall-clock, back to
back on a busy machine, the self-check 1678 against 1780 ms on the JIT
run (best of five). Kept. A flag per helper saying whether it can grow
the stack would spare the reload after the ones that cannot (rt_drop_at
above all, the free of every release) and take some of the bytes back:
a step for a later stage, as is the shared stub of 3b. (user)
AT5. The image's code section is mapped executable from the file. The
file lays every body and trampoline sixteen-aligned in one section at an
offset that is a multiple of 16 KB (SECTION_ALIGN, every page size the
toolchain runs on), the table before it says where each lies, and a run
maps the section with read and execute permission straight from the
file (memmap2), so that no machine code is copied and only the pages
the program runs are faulted in; where the system refuses an executable
mapping of the file (a noexec mount) the section is read and placed as
compiled code is, and an image in memory (a test's) is placed the same
way. renyi build --exe pads the executable to the same alignment
before the image, so that the embedded image's section maps from the
executable's own file. The image format is 3. The owner's answer of
2026-10-08 to the question the load's 69 ms raised: find the cost and
fix the largest within the round. What the profile found: the system
calls of a load take four milliseconds in all; the time went to the
first touch of fresh memory, twice over, once for the 8.7 MB read of the
file into a new buffer (44 ms under strace) and once for the copy of
the 7.8 MB of machine code into the arena's new pages (49 ms by the
JIT's own clock), a cost this machine (a Firecracker VM) makes heavy
and every machine pays in proportion; a file-backed mapping pays none of
it for the bytes it does not touch, and the page cache holds the rest.
Why a section rather than mapping each body: one mapping, one
alignment, one table. Why 16 KB: Apple silicon's page is that large,
and an image built on one machine should map on another of the same
target. Measured: the compiler's image loads in 16 ms where the run exits
at once (renyi run <image> with no arguments: the checker prints its
usage), against 27 ms with the section copied and the check as it was,
105 ms for the source and 86 ms for the .ryc; with the standard
library loaded by the checker before it fails on a missing file, 46 ms
against 167 for the source; hello 6 ms as an image against 8 from the
source; the load's instructions 62 to 32 million, the decode of the
program about 10 million of them and the consistency check 1 million
where it was 32, since it formatted a message for every op of the
program before knowing whether the check failed (the message is built on
failure now, the second cut of this decision); the image 8.8 MB (the
alignment adds up to 16 KB), the compiler's executable 26.6 MB. The
first measurements, under strace on a machine whose memory had not
been touched, put the read at 44 ms and the placing at 49; warm, the
placing cost 5 ms and the read a few; the mapping removes both whatever
the machine's state, and the page cache holds the code. (user)
AT6. Stage 3b of AT1, measured: the reference counts stay in place.
Two variants were built on AT4's binary and measured by the rule: the
frame pointer no longer reloaded after a helper that cannot move the
stack (STACK_SAFE: the free of a release, the grant of a frame, the
growth of the frames, the typed takes and resumes, the tag tests), and,
on top of it, retain and release as calls to the helpers
(rt_retain_at, which keeps a clone's count, and rt_drop_at, which
drops the value whatever the count) in place of AR4's inline sequences.
The calls stay, and the frame pointer is
not reloaded after a helper that cannot move the stack: retain and
release are the two calls, the inline sequences of AR4 are gone, and
the compiler's machine code is 5.6 MB where AR4 had made it 7.9. The owner's order of 2026-10-08 ended with this
stage, each variant by the rule. The numbers, against AT4's binary: the skipped reloads alone
raised the JIT run's estimate 1.0% and the code 0.7% (the pointer, live
across the call, saved and restored around it where the reload had
left it dead); the calls on top of them cut the machine code 7.91 to
5.62 MB (-29%; 122 bytes of body per op where the round began at 179),
the JIT run's estimate 14.92 to 14.83 billion cycles (-0.7%: 10.87 to
10.68 billion instructions, 102.2 to 86.4 million instruction misses,
85.1 to 98.8 million indirect mispredicts, the model's charge for the
calls through the table), the image's 11.15 to 11.18 (+0.3%: misses
142.6 to 96.3 million, indirect mispredicts 38.9 to 67.9 million); the
calls without the skipped reloads measured 14.85 and 11.21 billion, a
fifth of a percent behind, so the list stays by the rule, each of its
fifteen names a helper that grows nothing and runs no program code,
and a helper not listed is reloaded after, which is always sound. Why
the call beats the sequence: Value::clone and the drop are a match on
the tag with one increment or decrement, where the generic sequence
tested the tag's bit, the big-integer case and both payload words at
every site, and the sites were thousands. In wall-clock against the
binary of AT3, the best of five: the self-check 1886 to 1775 ms on the
JIT run (-5.9%), 1369 to 1351 as an image, the interpreter and
bench/records.ry and bench/primes.ry level. The stubs of AT1's plan
turned out to be the helpers the VM already had. (user)
AT7. The round closed by the owner on 2026-10-09, every stage of
AT1's plan measured and in (AT2 to AT6). Against the binary the round
began from (71965aa, the one AS4 left): the compiler's machine code
8.26 to 5.62 MB (-32%, 179 to 122 bytes of body per op), its image
17.5 to 6.5 MB, the self-check's estimated cycles 15.37 to 14.83
billion on the JIT run (-3.5%) and 12.63 to 11.18 as an image (-11.5%),
the image's load 152 to 16 ms where the run exits at once (most of the
152 was the checker's own work on the standard library, which the
profile of AT5 told apart), the self-check in wall-clock 1841 to 1775
ms on the JIT run and 1511 to 1351 as an image, hello 10 to 6 ms as
an image. What the round found beyond its plan: the two copies of a
load were the largest item on this machine because fresh memory's
first touch is dear (AT5); a static invariant the room check of AR4
already rested on removed a load from every stack access (AT4); and
the inline reference counts of AR4, the round's largest source of
bytes, lost to the VM's own helpers (AT6), the finding the round
opened on: a sequence inlined for speed can cost more in the cache than
it saves in instructions, and only the measurement tells. What is left
for a later round: RELEASES_INLINE (four calls against one
rt_truncate on a return), the indirect call through the helper table
(a tenth of the estimate in the model's charge; a direct call would
need a relocation per site, against AS1), and Int flattened into
Value for a one-compare clone and drop. The round the owner chose
next is the one benchmark behind CPython, the per-character loop of
bench/strings.ry (128 against 85 ms; primes 9.7, records 3.4 and
json_round_trip 1.7 times faster than CPython, hello 6 ms against
Python's 18): by its profile on the interpreter, a boxed constant
copied and retained per iteration, a one-character text allocated per
glyph, and a primitive call through the boundary per glyph; its measure
and its cuts are its own opening decision, after the profile on the JIT
tier. (user)
AU. Static types to the code generator (session 9)#
AU1. The round that brings the checker's static types to the code
generator, the cure the owner asked for in place of another cut, in
this order, each stage measured and kept by the rule below: (i) the
call to a primitive without the boundary: a native may carry a typed
entry from a fixed family of signatures (fn(&[Value]) -> Option<T>
for T one of bool, i64, f64 and Value; None means the
arguments are not the plain values the fast path takes and the general
path runs), called by the generated code with its arguments borrowed
where they lie on the stack and its result in a register; the
registration API's Native gains the optional entry (an addition to
AK2), the standard library's hottest primitives take one; a pure
primitive without one (no needs) runs on a flat path that enters none
of the boundary's checks, since none applies to it; an operand a typed
call borrows is neither retained before nor released after, when the
op that pushed it was a Load or a Const; (ii) the loop over a list
in the generated code: the iterator in a fixed layout that the code
reads and advances itself, as it does for a range (AG3); (iii) the
typed bytecode, format 5: both checkers record the type of every
expression of a body (Target::Typed, by span, as Target::Result
already travels), both emitters write a table of the types a program
uses and, per code object, the type of what each op pushes, and the VM
checks the annotations against its own inference of the three scalars
on the corpus before it trusts them; (iv) what the types buy: the field
read at an index known statically, the ability method chosen
statically, the loop variable typed, the retains and releases elided
wherever the consumer borrows; (v) left to later rounds: the
representation (small texts inline, Int flattened into Value, lists
of unboxed Integers, values in registers across ops), which the types
make worth doing. The measure: AT1's rule decides (the compiler's
self-check by KCachegrind's estimate of the cycles on the JIT run, the
interpreter and the image, tools/measure_size.sh), the four
benchmarks against CPython in wall-clock confirm (tools/bench.py); a
stage stays when the self-check's estimate on the JIT run falls, or
when a benchmark gains more than 5% while the self-check loses no more
than 1%. The round's first goal is bench/strings.ry past CPython, its
second the self-check a quarter faster than AT7 left it. The owner's
four answers of 2026-10-09, asked after the profile of
bench/strings.ry on the JIT tier; the owner chose the typed bytecode
over the session's recommendation of an inference inside the VM
(below), and folded the strings round AT7 had announced into this one.
The root cause, as the profile shows it: Renyi is statically typed,
but its bytecode and its VM are not; the checker's types die at the
emitter, every value carries a tag, every op reads it, the baseline
JIT recovers the three scalars by abstract interpretation (AR1) and
boxes everything else on the VM's stack with a helper call per op, so
the generated code is the interpreter unrolled: on the self-check it
runs 14% fewer instructions than the interpreter (AT1) and 7% faster
in wall-clock, and bench/primes.ry is 9.7 times faster than CPython
because it is all Integers. The strings loop ("0123456789".contains(glyph)
over 1,188,895 glyphs; 130 ms against CPython's 84 on this machine,
the first half of the program 23 ms of it) runs 966 instructions per
glyph on the JIT tier (callgrind, 1,149 million in all): 411 of them
(43%) cross the primitive boundary (rt_call 23, call_from_stack
101, call_primitive 87, run_primitive 48, status 40, guarded
24, effect_of 22, the drop of the two arguments 41, the copy into
the scratch buffer 25), 117 (12%) are the search itself
(is_contained_in 72, text_contains 45), 80 (8%) the iteration
(rt_iter_next 29, iterator_next 37, the item's clone), 55 (6%) the
retain and the clone of the constant and the glyph, 67 (7%) the
generated code, and the rest the first half of the program (the text
built from a hundred thousand pieces: rt_to_text 59 million through
core::fmt, rt_concat 48 million, append through the same
boundary). The glyphs themselves allocate nothing since AQ (the ASCII
table of Value::character). Why the typed bytecode rather than an
inference in the VM from the signatures the bytecode already carries
(param_types, returns, the field types of every shape): the owner's
choice; the inference would have been a second checker inside the VM,
sure only where the first was, and a call of a generic function or an
empty list literal has its type at the call site alone; with the
checker recording what it knows, the VM infers nothing and the two
checkers are held equal on one more thing by the judge of W7, as they
already are on Target::Result and Target::Number. Why the typed
natives through a signature family and not per primitive: the
generated code is address-free (AS1) and calls through tables; a
family of four result kinds over borrowed arguments is one table and
four helpers, and the natives stay ordinary Rust functions that an
extension can write too. Why the typed call takes Option: the fast
path sees plain values; a guarded argument, a big Integer or a failure
returns None and the general path does what it always did, so a
typed entry can never be less correct than the native it stands beside.
Why stage (i) comes before the typed bytecode: it needs no type the
bytecode lacks (the callee is known at every call site and its result
type is in returns), it removes the largest item of the profile, and
the typed bytecode's calls will target the same entries. What the types
do not change: the generated code still reads the tag before it takes
a fast path, since a value of Integer type may be big or guarded at run
time (AR1), so a type is the choice of the fast path and never a
promise the code relies on for its safety; the recordings, the replay,
the narration and the .ryc as JSON (Z1) stay as they are. (user)
AU2. Stage (i) of AU1 is in: the call to a primitive without the
boundary. A Native may carry a typed entry (Native::with_typed,
Typed::Bool, Int, Float or Value over fn(&[Value]) ->
Option<T>), which Registry::verify holds to the declaration (the kind
of the declared result; no needs, since the entry skips the boundary),
and forty-two primitives of the prelude carry one (the lengths, the
emptiness tests, contains, starts_with, ends_with, index_of,
get, contains_key, at, first, last, join, sum of Integers,
the trims and cases of a text, split, lines, characters,
replace, take, drop, reversed, the absolute values, at_least
and at_most of Integers, to_float, square_root, rounded). The
generated code calls such a primitive through rt_call_typed with the
arguments the Loads of boxed slots and the boxed Consts before the
call pushed borrowed (no retain before, no release after; borrowed_operands,
the mask of the call's arguments) and takes a scalar answer from the out
slot into its register; when the entry declines, the general path runs
with the borrowed arguments given their reference, and its boxed answer
comes back as BOXED, unboxed as a call through rt_call is, with the
hand-back to the interpreter at the op after the call. A pure primitive
without an entry runs through rt_call_pure on the flat path
(Vm::call_pure_from_stack: the memory check, the arguments into the
scratch buffer, plain_in_place, the native, guarded); the
interpreter's call! takes the typed entry in place
(call_typed_in_place) and the flat path too. CallKind per function
(General, Pure, Typed(kind), from the registry when the VM or
renyi build starts) is what the code generator compiles by; the
helper looks the entry up again at run time, so an image compiled with
an entry runs under a binary without one, through the general path.
Measured by AU1's rule against the binary of AT7 (7e09ca6): the
self-check's estimate on the JIT run 14.83 to 13.86 billion cycles
(-6.5%; 10.68 to 9.87 billion instructions, -7.5%), the interpreter
17.92 to 17.23 (-3.9%; 12.85 to 12.21 billion instructions), the
image 11.18 to 10.27 (-8.2%; 7.97 to 7.16 billion instructions,
-10.2%; the machine code 5.62 to 5.63 MB, 122 bytes of body per op as
before); in wall-clock bench/strings.ry 134 to 94 ms (CPython 81 on
the same runs; the interpreter 175 to 157),
primes 41, records 59, json_round_trip 96 ms by tools/bench.py
(CPython 528, 166 and 156), the self-check 1694 ms on the JIT run and
1256 as an image. The profile of strings after the stage (callgrind,
733 million instructions from 1,149, 617 per glyph from 966):
rt_call_typed 111 instructions a call where the boundary took 411,
the entry's own match on the two texts 20, the search 72 as before;
what is left of the loop is the iteration (rt_iter_next and
iterator_next, 82 a glyph, stage ii), the generated code's own 67,
the loop variable's retain and release (54), and the first half of the
program, now a fifth of the whole: rt_to_text through core::fmt
(586 instructions per Integer written into a text), rt_concat, and
append, which frees and allocates its Rc on every call
(take_list then Value::list), 400 instructions each. Why Option
and a fixed family rather than a signature per primitive: AU1. Why the
borrowed operands are only the Loads and Consts just before the
call: they push exactly one value each and pop none, so they are the
call's last arguments in order without an analysis of the stack
effects of every op; LoadMove is not among them (its operand is the
slot's reference, moved). Why the entry is looked up again at run time
rather than its address placed in the code: AS1, the code holds no
address, and a binary with other extensions may lack the entry. (user)
AU3. The small cuts the profile of AU2 named, in: rt_call_typed
syncs the pc only where something can go wrong (the general path, an
interrupt) and drops nothing when every argument was borrowed
(consume_arguments); a machine-word Integer writes its digits into a
text without core::fmt (integer::push_digits, digits; in render
and op_concat, so in every {...} hole and every to_text); append,
append_all, set and add on a list, a map or a set, and without,
change the collection through Rc::make_mut and keep its allocation
where take_list and Value::list had freed one and allocated another
on every call. Measured by AU1's rule against AU2's binary: the
self-check's estimate on the JIT run 13.86 to 13.83 billion cycles
(-0.15%), the interpreter 17.23 to 17.20 (-0.2%), the image 10.27 to
10.22 (-0.4%): the cuts are the strings loop's, the self-check only
holds; bench/strings.ry 94 to 84 ms best of seven, 87 by
tools/bench.py against CPython's 79 on the same runs (0.9 of
CPython's time), 77 as an image, which is past it; the first half of the
program 39 to 30 ms. The profile of strings (callgrind): 733 to 669
million instructions (563 a glyph); rt_call_typed 111 to 80 a call,
an Integer written into a text 586 to 108 instructions, append 400 to
50; the loop is now the iteration (rt_iter_next and iterator_next,
82 a glyph; stage ii), the search (72, Rust's memchr on ten bytes for
a one-byte needle), the typed call's helper (80), the generated code
(56), the entry's own match on its two texts (20) and the loop
variable's retain and release (about 40). (user)
AU4. Stage (ii) of AU1 is in: the loop over a list in the generated
code. The list iterator is ListIter (the items' address and count, the
position, the list that keeps the items where they are), in a fixed
layout inside a Native that is repr(C, u8) now (layout::TAG_NATIVE,
NATIVE_TAG, NATIVE_PAYLOAD, NATIVE_ITERATOR, ITER_ITEMS,
ITER_LEN, ITER_POSITION, held to the types by a test); at
IterNext on a slot the analysis did not type as a range, the generated
code reads the slot's tag and the native's, and for a list iterator
compares the position with the count, copies the item onto the stack
with one more reference and advances the position in place, leaving
the loop at the exit otherwise; anything else in the slot (a range
iterator made from a Range value, a value no analysis typed) goes
through rt_iter_next as before. The interpreter's iterator_next
reads the same struct (ListIter::next). Measured by AU1's rule
against AU3's binary: the self-check's estimate on the JIT run 13.83 to
13.66 billion cycles (-1.3%; 9.78 to 9.74 billion instructions, the
instruction misses 77 to 66 million), the interpreter 17.20 to 17.27
(+0.4%, within the rule: the JIT run decides; ListIter::next branches
where the old iterator did not), the image 10.22 to 10.08 (-1.4%; the machine code 5.63 to 5.70 MB, 123 bytes of body per op, the inline walk's price); bench/strings.ry 84 to 83 ms best of
seven and 87 to 78 by tools/bench.py, CPython 79 on the same runs: at
par, the round's first goal reached in wall-clock on this machine but
not yet with a margin; 76 ms as an image. The profile of strings
(callgrind): 669 to 625 million instructions, 525 a glyph; the
iteration's 82 (rt_iter_next, iterator_next, the clone) became 20
in the generated code and 21 in rt_retain_at for the item's reference.
What a list iterator's items pointer rests on: a list another holder
changes is copied first (Rc::make_mut, decision O1) and a list the
iterator alone holds is changed by nobody, so the items never move
while the loop runs; the interpreter and the generated code agree on
the position's meaning (the index of the next item, never past the
count), so a frame may change hands in the middle of a loop as it does
for a range (AG3). Why the tag checks stay: the slot's kind is Iter
for every loop whose source the analysis did not see as a range of
small Integers, and such a source may be a Range value at run time. (user)
AU5. Three micro cuts after AU4, in: the typed call's general path and
its value answer live in their own functions (typed_call_general,
typed_value_answer, typed_over_memory), so that rt_call_typed
itself is the fast path alone; contains on a text looks for a one-byte
part in a text of at most 32 bytes by a plain loop (text_has), where
Rust's search set up more than it searched; push_digits pushes the
digits as characters instead of checking them as UTF-8. Measured by
AU1's rule against AU4's binary: the self-check's estimate on the JIT run
13.66 to 13.75 billion cycles (+0.6%, the instructions +0.1% and the
instruction misses 66 to 73 million: the code's layout moved, the work
did not; within the rule's one percent), the interpreter 17.27 to 17.24
(-0.2%), the image 10.08 to 10.12 (+0.4%); bench/strings.ry 83 to 78
ms best of seven and 78 to 77 by tools/bench.py, CPython 79 to 82 on
the same runs; the profile of strings 625 to 589 million instructions
(-5.7%; 496 a glyph): rt_call_typed 80 to 72 a call, the entry with
its search 92 to 70, the digits of an Integer unchanged (the characters
cost what the UTF-8 check cost). The stage stays by the rule's second
clause: a benchmark gained more than 5% and the self-check lost less
than 1%. What the loop of strings is now, by the glyph: the generated
code's own 77 instructions (the walk of the list, the push of the
glyph, the store into its slot, the branch), the typed call's helper
72, the entry's match and search 70, the release of the previous glyph
and the retain of the next about 40, the rest the first half of the
program and the list of glyphs built and dropped. (user)
AU6. Stage (iii) of AU1 is in: the typed bytecode, format 5. Both
checkers record the type of every expression of a body at its span, as
Target::Typed (check.rs: infer wraps infer_inner and notes the
span and the type; finish_body zonks each and records the ones without
a variable left, as it does Target::Result; bodies.ry: the same,
record_typed appending the body's noted types to the references at
once). Both emitters write, per op, the index of that type in the
program's table of types (result_types, which holds the context types
of ResultType ops and every noted type now, first use first):
Compiler::emit and emit.ry's emit look the op's span up
(type_index_at, type_index); emit_untyped writes none, for the one
op that pushes something other than its expression's value under that
expression's span (the comparison of a literal pattern). Code::types
travels in the JSON ("types" per code object, null where none), in
the binary encoding (encoding 2) and so in the image (format 4); the
file's consistency check holds the list's length to the ops' and every
index inside the table. Op::pushes_its_expression names the ops whose
annotation is the type of what they push (Const, Load, Call,
Field, Binary, ...); the others (ToText, IterNext, Unpack, the
jumps) carry their expression's type too but push something else or
nothing, so the VM may read the annotation for the former alone.
abs_of_type sees through a refined subtype to its base (its values are
the base's). The test tests/typed.rs holds the annotations to the
inference of the baseline JIT over the corpus, the clean conformance
programs and the compiler: wherever the analysis types what an op pushes
as one of the three scalars, the noted type must be that scalar's, or a
maybe of it; the two emitters are held equal on the new field by the
judge of Z3 and the two checkers on the new target by W7. Measured:
the compiler's checker as a bytecode file 8.99 to 9.67 MB (+7.6%;
46,272 ops of which 30,309 (65%) carry a type, 425 types in the table);
the VM reads nothing of it yet (stage iv), and still the self-check's
estimate rose, 13.75 to 16.67 billion cycles on the JIT run (+21%),
17.24 to 20.20 on the interpreter, 10.12 to 12.75 as an image, because
the program measured changed, not the VM: the self-check is the checker
written in Renyi checking bodies.ry, and that checker now notes the
type of every expression, through lists held in a record, which Renyi
copies on every append (a field read clones the list, so append finds
it shared), and joins into the module's references body by body; the
Rust front end's own share is small (renyi check compiler/checker.ry
538 to 561 million instructions, +4%). The judge of Z3 and W7 runs in
117 s. The next commit bounds the copies. Why every op and not the pushing ops
alone: the emitters would have had to agree on a stack-effect predicate
per op kind in two languages, where one lookup per emitted op agrees by
construction; the file pays 7.6%. Why the table is result_types and
not a second one: one index space for the two uses, one dedup in each
emitter, and the .ryc keeps its key. Why the one emit_untyped: the
literal pattern's comparison is the only op the emitters write under a
span whose expression has another type than what the op pushes and
whose kind pushes_its_expression lists; the query terminals' Add,
Nothing and Load under the query's span push what the query's type
says. What the test found on the way: the literal of a refined field
(Version(major: 1, ...)) is typed with the refined subtype, which the
inference now reads as the base; a maybe Integer binding the analysis
proves always an Integer is compatible, not a disagreement. (user)
AU7. The typed notes recorded cheaply, after AU6's measurement: the
checker written in Renyi keeps a body's notes in chunks of 64
(typed, typed_chunks: a list held in a record is copied on every
append, since the field read clones it and append finds it shared,
so the copy is bounded), keeps the typed references of each body apart
(typed_references, one list per body) and joins them into the module's
references once (all_references); the Rust emitter finds a type's
index in the table through a map (type_indices) instead of a scan.
Measured by AU1's rule against AU6's binary: the self-check's estimate
on the JIT run 16.67 to 14.58 billion cycles (-12.5%; 6.0% above AU5's
13.75, before the notes), the interpreter 20.20 to 18.04 (AU5 17.24),
the image 12.75 to 10.66 (AU5 10.12); the judges of Z3 and W7 in 102 s
(117 s at AU6). What is left of the notes' cost is the Renyi checker's
own: a SpanTy record and two record copies of the checker per
expression, the zonk of each note at the body's end, a reference record
per note. What this showed about the language: the pattern record with
field: record.field.append(x) copies the list on every call, in the
compiler everywhere (references, diagnostics, vars, scopes); an
emitter that recognised the update of a field of a uniquely held record
and moved the field out and back in would make the compiler itself
faster by a large factor on its hottest paths, a candidate for a later
round. (user)
AU8. Stage 4 of the typed round, steps A and B: the types in the
abstract state and the field read at a static index. The analysis
carries the noted type with every boxed value (Abs::Boxed(Option<u32>),
the index into result_types; SlotKind::Boxed(Option<u32>) by the
stores; Analysis::slot_types from the loads' annotations, else the
stores', else the parameter's declared type); the bytecode file carries
every parameter's type as an index into the table (param_type_indices
of a function, looked up in the table once it is complete and never added
to it, so that the table stays what the expressions made it; format 6,
binary encoding 3, image format 5), and abs_of_params decides by it, so
a parameter of a refined subtype of Integer is passed in a register as an
Integer is. A LoadField whose slot has a record type, and a Field whose
holder on the stack has one, check the holder's tag and type against the
expected type and read the field at the index the type's shape gives, with
no cache (static_field); the kind of what a field read pushes comes from
the op's own annotation (abs_of_field_at), the name-based join only
without one. The generated code keys its landings, its hand-backs and its
state check against the analysis by the kinds alone: the analysis joins
the states of every round of its fixed point and loses a type where a kind
changed on the way. Measured by AU1's rule against AU7's binary: the
self-check's estimate on the JIT run 14.58 to 14.55 billion cycles
(-0.2%), the interpreter 18.04 to 18.04, the image 10.66 to 10.54 (-1.2%);
the machine code 5.83 MB, 125.8 bytes of body per op, 771 deopt points.
Why so little, from a profile of the JIT run (callgrind, 10.28 billion
instructions): the generated code runs 9.5% of the instructions; the
interpreter loop 19.6% and its frames 3.3% (the self-check compiles 30
code objects, the rest stays below the hotness rule of AR5); reference
counts 17.1%; the VM's glue around the helpers 17.4% (push_frame_in_place,
op_load_field, plain_all, refined_record, call_pure_from_stack,
op_with, guarded, make_mut, frame_grant); allocation and memcpy
8.6%; the helpers 7.4%; comparisons 6.6%; Cranelift 4.8%; the Rust front
end's check of the compiler 4.5%; the natives 3.3%. Of the 94 LoadField
sites in the compiled code objects 46 take the static path and 12 of 12
Field sites; 35 of the rest read a slot no annotation types (a binding
from a match or an otherwise) and 9 a field every variant of a sum type
has (Ty), which a later step could serve too. The step stays by the
rule's first clause. What the profile says about the plan: step iii of
AU1 (the ability method chosen statically) has nothing to buy, the
compiler emits no CallAbility on its hot paths (a concrete receiver's
method is a direct Call already); the loop variable typed (step iv's
third item) types what the loads' annotations type already; the cost is
in the interpreter's share, the reference counts and the copies of
records and lists that record with field: record.field.append(x) makes,
not in what the generated code computes. (user)
AU9. The round's order after AU8's profile, the owner's answers of
2026-10-09: first the image cache of renyi run (the steady state of an
image from a program's second run on: the self-check's image row is 28%
below its JIT run), then, in this round, the update of a uniquely held
record in place (with and append without a copy), the comparisons on
borrowed operands, and the parameters borrowed across direct calls. Two
items of AU1's step iv are dropped: the ability method chosen statically
(the compiler emits no CallAbility on its hot paths; a concrete
receiver's method is a direct Call already) and the loop variable typed
from the list's item type (the loads' annotations type it already). The
rule stays AT1's: the cold JIT run, without the cache, is the row that
decides (the measuring scripts run with the cache off); the run from the
cache is reported beside it. Measured on AU8's binary for the record,
the hotness factor of AR5 against the self-check's estimate: 2000 14.56,
3000 14.56, 4000 14.48, 6000 14.48, 8000 14.55, 16000 15.01 billion; the
factor stays 8000, the differences below it being within half a percent
and the cache changing what the factor is for. (user)
AU10. Stage 5 of the typed round: the image cache of renyi run. A
run of run, record or test (and serve without --watch, which
is run) that compiled machine code leaves the program's image (AS1)
in a cache directory of the user's, built after the run by the same
binary, renyi build --cache <file>, spawned in the background with no
standard streams; every later run of the same program by the same
renyi on the same machine loads its code from the cache and compiles
nothing, and reproduce reads it too. An entry is named by a hash of
the renyi version, the host's target and the program's binary
encoding (AT3); a hit is an image whose header fits the machine and
whose program is, byte for byte, the program the run compiled, so that
a changed, corrupted or foreign file is a miss and the cache never
changes what runs. The directory is renyi/images under the system's
cache directory or RENYI_CACHE_DIR; the images together are kept
under 256 MB, the least recently used going first (a hit refreshes the
file's modification time); a lock file keeps a second build of the same
program from starting while one runs (ten minutes, then it is taken for
dead). The cache is off under --no-cache (run, record, test),
under RENYI_NO_CACHE, for a run on the interpreter (--interpret,
--explain, --profile), for a program loaded from an image, and for
everything cargo runs (.cargo/config.toml), so that a test runs the
same way every time; CI sets it too. Why in the background: the build
of the compiler's image takes about three seconds at speed, more than
the run it follows; a script an agent runs once pays nothing, and the
second run finds the image. Measured on the self-check (AU9: the cold
JIT run decides and stays as it was, the cache being off there):
the run from the cache 11.23 billion cycles against the cold JIT run's
14.23 (-21%; the image alone 10.31, the difference being the front end's
check of the compiler's sources and the encoding compared, 0.75 billion
instructions); the cold JIT row moved from AU8's 14.55 to 14.23 with
its instructions equal within 0.1% (10.27 against 10.28 billion), the
change being in the simulated data-cache misses, which follow the
binary's layout and not this stage. Wall-clock on this machine, with a
cachegrind run on another core: the self-check 2.2 to 2.5 s cold, 1.6 to
1.8 s from the cache; hello 8 ms either way; the first run with the
cache 2.1 s, the image of 6.8 MB in the cache two seconds later. (user)
AU11. Stage 6 of the typed round: the update of a uniquely held record
in place (bytecode format 7, binary encoding 4, image format 6, code
format 4). Two ops: WithSlot { slot, fields }, whose base is the
record in the slot, moved out (Nothing is left) and updated in place
when it is held once (Rc::make_mut; the allocation stays either way,
where with freed the record's and allocated another), the refinements
of the type checked on the result as with checks them; and TakeField
{ slot, name, site }, which pushes a field of the record in the slot,
moved out when the record is held once (Nothing is left in the field
until the WithSlot that follows puts the field's new value in) and
cloned when the record is shared, through the site's cache as
LoadField reads. Three rules, in both emitters, which the judge of Z3
holds equal: (a) change x to x with U and return x with U, x a
local: when every update is f: x.f.method(args) with the names
distinct and no argument pinning x, each receiver x.f is a
TakeField and the record is updated with WithSlot (the takes); else,
when no update may leave the loop (break, continue), a WithSlot
with the fields read as they are (the move); else the copy as before.
(b) change x to CALL: x is moved into the call with LoadMove when
it is the receiver (O1) or, new, when it is the one argument that is x
itself, and nothing else in the call pins x. (c) pins(expr, name),
the predicate behind both: the expression reads the name anywhere, or
holds a break or continue outcome; the second is new for O1's rule
too, which moved the receiver out and let an argument leave the loop
with the slot Nothing. What makes the takes safe: a hole exists only
in a record held once, which only the slot sees; the slot is dead
(return) or stored into (change) right after the statement; a
handled region is opened inside an expression only, never around a
statement, so a failure during the updates leaves the frame; a break
or continue inside an update is excluded by the rule; the taken field
is read nowhere else, since no argument mentions x and the names are
distinct; a record that is shared, or a holder that is not a record, is
read as before. The let y be x with ... form (the plan's rule c) needs
the liveness of x after the statement and is left out of this stage:
the two hottest with sites of the Renyi checker (fresh, infer)
have that form, so the next profile decides whether it is worth a
liveness rule in both emitters. In the compiler's checker program: 71 of
159 with sites are updates in the slot, 17 of them with their field
taken, and 429 values are moved into calls where 180 were (LoadMove);
the bytecode file 9,751,963 to 9,743,893 bytes. Counted on the
self-check with the VM instrumented for the purpose: of the 206,427
updates run, 70,922 are WithSlot and 23,848 find the record held once;
of the 8,258 takes, 2,305 move the field; the rest find the record
shared, by a Done record that carries the checker beside its value
(let after be done.checker, then done with checker: updated) or by a
binding still live after the statement. Measured by AU1's rule against
AU10's binary (586f4b1), both binaries on the same machine: the
self-check's estimate on the cold JIT run 14.23 to 14.16 billion cycles
(-0.5%; 10.27 to 10.26 billion instructions), the interpreter 17.76 to
17.80 (+0.2%; 12.73 to 12.72 billion instructions, the instruction
misses up with the binary's layout, within the rule), the image 10.31 to
10.23 (-0.7%; 7.19 to 7.18 billion instructions; the machine code 5.79
MB, 125.2 bytes of body per op, 771 deopt points), the run from the
cache 11.23 to 11.16 (-0.7%); in wall-clock by tools/bench.py on this
machine bench/records.ry 53 to 52 ms and the self-check 1,763 to 1,774
ms on the JIT run, 1,364 to 1,313 ms as an image, best of seven with the
two binaries alternating, which is noise: no change in wall-clock. The
stage stays by the rule's first clause, and the gain is small for the
reason the counts give: the hot updates of the checker find their record
shared, so the in-place path they were built for rarely runs; what would
make it run is the move of the last read of a binding (a liveness rule)
and the field taken out of a record that is updated with the result
later, which the plan of AU1's stage iv did not foresee and which the
owner is asked to order. (user)
AU12. The owner's answers of 2026-10-09 after AU11's finding: (i)
stage 7 now, the comparisons on borrowed operands, and stage 8 after it;
the copies that the checker's shared records keep are left to the
representation round (AU1's step v), where a liveness pass over the
bytecode (the last read of a slot as a move) would serve every form at
once, rather than more syntactic rules in two emitters now; (ii) the
round's second goal, the self-check a quarter faster than AT7 left it
(14.83 billion estimated cycles), is judged on the cold JIT run, the row
AU9 made the one that decides, and not on the run from the image cache
(11.16 against 14.83 already, which removes the compiling and not the
running); after stages 7 and 8 a new profile decides the stages that
follow, the representation items of AU1's step v among them, until the
goal is met or the owner closes the round; (iii) whether a command of
the binary runs the front end written in Renyi in place of the Rust one
is decided after this round, with the self-check's speed then, and
nothing is added now (the cost measured in session 10: checking
compiler/bodies.ry takes 0.083 s with the Rust front end and 1.87 s
with the Renyi checker on the cold JIT tier). Asked in a batch of
three after AU11's measurement; the owner took the recommended option of
each. (user)
AU13. Stage 7 of the typed round: the comparisons on borrowed
operands, in the generated code alone. A Binary comparison (is, is
not, is less than, is at most, is greater than, is at least) on
two boxed operands goes through rt_compare, which compares them where
they lie on the stack and answers the Boolean into the out slot, from
where the generated code takes it into a register: two small Integers,
two texts, two Booleans, Nothing beside a value, and two variants
without fields of a type without its own equals are answered there;
anything else (a record, a variant with fields, a Decimal, a Float, a
declared equals or compare) takes the general path, binary_values,
whose boxed answer comes back as BOXED and is taken into the register
as a typed call's is. The operands a Load of a boxed slot, a boxed
Const or Nothing pushed just before the comparison are borrowed as
the typed calls' arguments are (AU2): pushed without a reference of
their own and consumed without a release; the general path gives them
their reference first. A Boolean carries no origins, so a guarded
operand is looked through. No op, format or emitter changes: the
interpreter compares as before; the image's code format is 5 (the helper
among the helpers). Why the comparison and not every binary operator:
the others on boxed operands are arithmetic on Decimals and big
Integers, rare in the self-check, and their answers are boxed. Why
Nothing joins the pushes that borrow: x is not nothing is a fifth of
the checker's comparisons, and Nothing holds no reference. Why a
LoadField operand is not borrowed yet: its helper path wraps a guarded
holder's field anew, so the code cannot tell a borrowed push from an
owned one without the helper saying so; the 33 LoadField ... is sites
of the checker program wait for that. Why equal asks the left
operand's type alone: the VM's equal does, so Nothing on the left is
answered at once and a record on the left with a declared equals is
not. Of the 722 comparisons in the checker program, 233 are Load Const
is on a text, the shape the self-check runs most (Const Binary 4.7
million of its 6.8 million Binary ops). Measured by AU1's rule against
AU11's binary (aaa44f6), both on this machine after a restart of the
container (cachegrind's simulated cache misses change between boots, the
same binary giving 1.15 and 2.60 million last-level misses on two boots
with its instructions equal within 0.01%, so the two binaries of a
comparison are measured on one boot): the self-check's estimate on the
cold JIT run 14.44 to 14.12 billion cycles (-2.2%; 10.26 to 9.95 billion
instructions, -3.1%), the interpreter 18.07 to 18.09 (+0.15%; the
instructions equal within 0.01%, 12.72 billion, once the three fast
paths small_binary, text_binary and boolean_binary were inlined by
force: with a second caller the compiler had stopped inlining
text_binary into binary_values, which had cost the interpreter one
percent of its instructions), the image 10.40 to 10.05 (-3.4%; 7.18 to
6.80 billion instructions, -5.2%; the machine code 5.79 MB, 125.2 bytes
of body per op, 771 deopt points), the run from the cache 11.38 to 11.03
(-3.1%; 7.94 to 7.56 billion instructions). The profile of the JIT run
(callgrind): rt_binary (188 million instructions) and its answer
through status are gone, rt_compare runs 307 million with the fast
comparisons inlined, binary_values 236 to 92 million, the retains of
the operands 94 to 68 million and the drops of values 664 to 595
million. Wall-clock on this machine, noisy today (eight percent between
runs of one binary): the self-check 2.57 to 2.42 s on the JIT run and
2.00 to 1.77 s as an image, best of seven with the two binaries
alternating, bench/json_round_trip.ry 133 to 121 ms, the other
benchmarks within the noise. The stage stays by the rule's first clause.
(user)
AU14. The owner's answers of 2026-10-09 after AU13's measurement and
the profile of the stage: (i) stage 8 of AU9, the parameters borrowed
across direct calls, is skipped: the retains and the releases of the
generated code are 2% each of the self-check and the parameters' share
of them smaller, the implementation would touch every exit of a frame
(the interpreter's return, the unwinding on a failure, the hand-back,
the generated code's return) with a borrowed mask per frame, and the
callee's own moves out of the slot (WithSlot, TakeField, LoadMove)
would have to be excluded; it stays recorded here for a later profile
that shows the parameters' retains to matter; (ii) the next stage is a
faster compilation tier, so that more code runs compiled on the cold JIT
run: the profile puts 45% of the run under rt_call, the calls that
found no generated code and ran their callee on the interpreter, with 30
code objects compiled under the hotness rule, and the image row, every
code object compiled, runs 29% fewer instructions; the session's
measurement of the compile cost followed, and the owner's third answer,
after it, chose the most thorough route (AU15), asking whether the
compile thread and a template tier combine, which the session answered:
the thread first, the template tier decided by its measurement; (iii)
the measure of that stage is the self-check's wall-clock, best of seven
with the two binaries alternating on one machine, with the cachegrind
rows reported beside it, since a compile thread's instructions count in
cachegrind's total as much as the interpreter's. The measurement of
the compile cost that the second answer asked for, on the binary of
AU13: under the hotness factor 8000 the self-check compiles 54 code
objects (1,580 ops) in about 140 ms, two thirds of it register
allocation, 42 microseconds an op (about 130 thousand instructions),
with 29 Cranelift instructions and 2.1 blocks per op; compiling
everything called (564 code objects, factor 0) takes 1.28 s and the run
2.76 s against 1.76 s at 8000; the factors 2000, 500 and 100 are slower
than 8000 by 13 to 27%; Cranelift's single-pass register allocator
halves the compile time and the code it makes runs 10% slower. For more
code to be compiled profitably on the interpreter's thread, the cost per
op would have to fall five to ten times, which no knob of the current
tier gives. (user)
AU15. Stage 8 of the typed round, in place of AU9's third item
(skipped by AU14): the JIT's compilation on a thread of its own. A hot
code object is handed to a compile thread, started at the first hot one,
with Cranelift's target and contexts of its own; the interpreter runs
the code object until its machine code comes back through a channel, and
places it at the next ask for that code object (a call, or a loop
header). The hotness factor on that path is HOT_FACTOR_BACKGROUND,
100, where it was 8000 (AR5) when the interpreter's thread paid for
every compilation: a code object is handed over once it has run a
hundred times its size in ops. The interpreter's thread stays the
compiler under RENYI_NATIVE_SYNC, under RENYI_NATIVE_HOT=0
(everything compiled at its first call, which the tests rely on to run
the generated code) and on a machine with one hardware thread, at the
factor 8000 as before; RENYI_NATIVE_HOT=N sets the factor on either
path. renyi build compiles on its own thread as before. The thread
reads the program through a raw pointer (ProgramRef), sound because
the program is never written while it runs and the thread is joined when
the JIT is dropped, before the program the VM borrows; the constants'
reference counts, which the interpreter changes, are read by nobody on
the thread. Why a thread and not a cheaper tier first: AU14's
measurement; the thread removes the compile cost from the interpreter's
path on every machine with a second hardware thread, where the template
tier would have cut it on one. Why the factor 100: measured by this
stage's rule (AU14: the self-check's wall-clock, best of seven with the
binaries alternating on one machine), the self-check on the JIT run
against AU13's binary (1,727 ms): on the interpreter's thread at 8000
1,744 ms (+1%, the same code), on the compile thread at 8000 1,755 ms
(+1.6%: 54 code objects, the handing over and the placing for nothing),
at 2000 1,572 ms (-9.0%), at 500 1,557 ms (-9.9%), at 100 1,527 ms
(-11.6%), at 20 1,578 ms (-8.6%); bench/records.ry 52 to 49 ms at 100
(46 at 20), primes 41 to 37, strings 81 to 79, json_round_trip
unchanged. Confirmed on the binary with the factor built in, against
AU13's, alternating best of seven: the self-check 1,723 to 1,548 ms
(-10.1%), primes 42 to 37 ms (-11%), strings 77 to 75,
json_round_trip 91 to 92, records 49 to 51 (within the noise of a 50
ms program), hello 8 to 7. The cachegrind rows beside it, as AU14's
rule asks: the JIT run 9.95 to 13.22 billion instructions and 14.12 to
18.29 billion estimated cycles, the compile thread's 3.3 billion
instructions (about 210 code objects at the factor 100) counted in the
total as much as the interpreter's, which is why the rule of AT1 would
have refused this stage and AU14 changed the measure for it; the
interpreter 12.72 billion instructions as before, the image 6.80 and the
run from the cache 7.56, unchanged, since neither compiles at run time.
What the thread does not change: the interpreter stays the reference and
runs every code object whose code is not back yet; the recordings, the
replay and the narration run on it alone; a run's result is the same on
either path, since the generated code hands a frame back wherever its
assumptions fail (AR1). What is left open: the pass table of
RENYI_NATIVE_REPORT is the interpreter's thread's, empty when the
thread compiled; a template tier (AU14's question) is decided by a
profile of this stage on one and two hardware threads. (user)
AU16. The owner's answers of 2026-10-09 after AU15's measurement: (i)
the template tier of AU14's question (a first tier of machine-code
templates per op without Cranelift, which would serve the machine with
one hardware thread, where the compile thread brings nothing, and
shorten the wait for the code everywhere) is to be built, as the next
large item after the stage below; (ii) the next stage now is the
liveness analysis over the bytecode: the last read of a slot as a move,
so that a value reaches its consumer held once and the updates in place
of AU11 find it so, estimated at three to six percent of the self-check
from the counts of AU11 (nine updates in ten found their record shared),
chosen over the representation items of AU1's step v, the two micro-cuts
(a fieldless variant as a constant, a borrowed LoadField operand) and
the closing of the round. The measurement that framed the questions:
the self-check's wall-clock on the binary of AU15 against AU13's,
alternating best of seven, on four hardware threads -10.1%, on two
(taskset) -6.2%, on one +0.8% (the old path runs there); the profile
of the image row (6.80 billion instructions, every code object
compiled): the drops of values 10.9%, the clones 4.8%, the frames pushed
4.9%, the copies of with about 3%, the comparisons 3.1%, the field
reads through the cache 1.5%; the cold row's goal of AU1 (a quarter
below AT7) stands at -4.8% and is out of reach of stages of one to three
percent each. (user)
AU17. Stage 9 of the typed round: the last read of a slot as a move, a
liveness pass in the VM (renyi_vm/src/liveness.rs). Before a program
runs (run_program, run_tests, reproduce, the sandbox of AP1) and
before its image is built (renyi build, the cache of AU10), the VM
takes a copy of the program and replaces every Load of a slot that no
path reads again before the slot is written or the frame ends by a
LoadMove, so that the value reaches its consumer held once and an
update in place (O1, AU11) finds it so. The liveness is the usual
backward one over the ops: the successors of an op are the next op
unless the op leaves the frame or jumps away, the target of a jump, the
exit of an IterNext, and, for every op between a PushHandler and its
target, that target, since a failure anywhere in the handled region
lands there with the slots as they are; the reads are Load,
LoadMove, LoadField, TakeField, WithSlot, IterNext,
CheckDeadline and UnwindStack, the writes Store, IterInit,
Deadline and MarkStack. The bytecode file, the image's program and
the cache's key stay what the emitters wrote: the pass is the VM's own
business, as the machine code is (AG1), so the two emitters and their
judges are untouched. The generated code borrows a moved load for a
typed call or a comparison as it borrows a plain one
(borrowed_operands of codegen.rs): the entries read their arguments
where they lie and update nothing in place, so the slot keeps its value,
which nothing reads again, and the helper counts the copy out; moving
such an operand out and releasing it after the call, as the first build
did, cost bench/strings.ry 10%. Why in the VM and not in the two
emitters, which the owner's answer named: one analysis instead of two
held equal by a judge, no change to the bytecode file, and the moves
reach a program loaded from a bytecode file or an image too; the cost is
a copy of the program per run: on the checker program (958 code objects,
46,238 ops) the copy takes 0.9 ms and the pass 5.0 ms in all, 0.3% of
the self-check. Why the handled regions are intervals in the op order:
the emitters keep PushHandler and PopHandler balanced on every path
(a break or continue pops the regions it leaves before its jump), so
every op that can fail into a handler lies between the push and the
target, and the ops in that interval that run with the handler already
popped get an edge they do not need, which keeps a value live a little
longer at worst. What the pass changes in the checker program: 6,261 of
its 9,611 Loads become moves (the emitters wrote 429 LoadMoves;
6,690 after); of the 24.6 million Loads the self-check runs, 13.0
million are moves now; counted on the interpreter with the VM
instrumented as for AU11: of the 206,427 updates run, 36,551 find the
record held once where 23,848 did, and of the 8,266 takes 3,491 move the
field where 2,305 did; the rest still find the record shared, by the
Done record that carries the checker beside its value (the field taken
out of a record that is updated with the result later, the item left for
a later stage). Measured by AU1's rule against AU15's binary (30db0f3),
both binaries on one boot of the machine: the self-check's estimate on
the cold JIT run 18.29 to 17.89 billion cycles (-2.2%; 13.22 to 12.94
billion instructions, the compile thread's work counted in), the
interpreter 18.09 to 17.54 (-3.0%; 12.72 to 12.60 billion instructions),
the image 10.04 to 9.71 (-3.3%; 6.80 to 6.69 billion instructions; the
machine code 5.79 to 5.69 MB, 123.1 bytes of body per op, 771 deopt
points), the run from the cache 11.02 to 10.68 (-3.2%); the first build,
which moved the borrowed operands out, measured 18.15 on the cold run
and 9.80 on the image. In wall-clock, best of fifteen with the two
binaries alternating: the self-check 1,538 to 1,464 ms (-4.9%) on four
hardware threads, 1,575 to 1,469 (-6.8%) on two (taskset), 1,772 to
1,713 (-3.3%) on one; bench/records.ry -2.3%, json_round_trip -2.2%,
primes -1.1%, strings within noise; on the interpreter
(--interpret) the self-check 2,107 to 1,945 ms (-7.7%) and strings
182 to 149 ms (-18%), more than the estimate says, as the clones it no
longer makes touched the counts of values the simulated caches hold. The
stage stays by the rule's first clause; the estimate of AU16 (three to
six percent) is met on the interpreter and on the image and not on the
cold JIT run, where the compile thread's work is a sixth of the total.
(user)
AU18. The owner's answers of 2026-10-09 on the design of the template
tier (AU16): (i) the machine code is emitted by a small x86-64 assembler
of the VM's own, each op a fixed sequence that keeps every value boxed
on the VM's stack and calls the helpers of the Cranelift tier for
everything but the trivial ops, over copy-and-patch stencils (the same
code for a build step and relocations more) and over Cranelift stripped
of its optimizations (half the cost at best, AU14, fifty times short of
what compiling at the first call needs); (ii) a code object gets its
template code at its first call, synchronously, on every machine alike
(microseconds per code object), over a small factor on the interpreter
and over the whole program at load; (iii) the template code counts the
hotness itself, at its entry and at its loop headers, and asks for the
promotion to the Cranelift tier with today's factors (100 on the compile
thread, 8000 synchronously where there is none), the Cranelift code
replacing the template entry at the next call, images and the cache
staying the Cranelift tier's, over a promotion only beside a compile
thread and over no promotion at run time; (iv) x86-64 in this round
(Linux, macOS and Windows: the System V and the Windows x64 conventions
both), aarch64 as a later stage with the sequences shared, the other
targets keeping the interpreter and the Cranelift tier. The design as
put to the owner (the handoff's section "The template tier: the design
study"): the analysis of infer.rs settles the code object (the static
depth, the handled regions, the block starts; one it rejects stays with
the interpreter); the frame is in the interpreter's layout at every op
(the locals, then the operands, the stack's length base + locals +
depth known statically as AT4 has it), so there is no hand-back and an
entry at a loop header fills no registers and refuses nothing; the
function has the Entry signature of a trampoline (the VM, the base,
the pc; a status out: RETURNED with the value on the caller's stack,
INTERRUPT); the trivial ops are inline (Const, Nothing, Load,
LoadMove, Store, Pop, Dup, the jumps, the tag tests, the Boolean
branches), every other op a call to the helper the Cranelift tier calls
for boxed operands followed by the status check (CONTINUE falls
through, FAILURE lands on the floor of the innermost handled region
through rt_settle_handler or leaves through rt_unhandled, any other
status leaves the function); calls go through rt_call, rt_call_typed
(with the mask of borrowed_operands) and rt_call_pure; the code
holds no address (the helpers, the constants and the direct table
through NativeState, AS1), keeps the VM, the base and the stack's
pointer in callee-saved registers and reloads the pointer after a helper
that may grow the stack; every native test and the conformance suite run
on the tier too (RENYI_NATIVE_TIER=template forbids the promotion);
the measure is AT1's rows with the wall-clock of the self-check on one,
two and four hardware threads beside them, the goal the self-check on
one thread within 15% of the image row. The measurement that framed the
questions, on AU17's binary: the cold JIT run against the image
(tools/bench.py, best of five) on one hardware thread 1,647 to 1,213
ms (+36%; primes +34%, records +26%), on two 1,473 to 1,221 (+21%),
on four 1,467 to 1,214 (+21%); on one thread 54 code objects of the
self-check are compiled (factor 8000) and 510 called ones stay cold,
with 176,735 calls from generated code to the interpreter; the
interpreter's dispatch (run_frames less the helpers) is 46% of its
instructions, which is what the tier removes while it keeps the ops'
work, so template code should run at about two thirds of the
interpreter's instructions on boxed code; the short programs of an agent
(7 to 25 ms, nearly all the front end) are not what the tier is for, the
runs from a tenth of a second upwards on the machine with one thread
are. (user)
AU19. The template tier as built (decisions AU16 and AU18; code format
6, image format 7): crates/renyi_vm/src/native/template/. x64.rs, a
small x86-64 assembler: the thirty-six instruction forms the sequences
need, labels with relative jumps patched at the end, so that the code
holds no address, and the two conventions (System V: the arguments in
rdi, rsi, rdx, rcx, r8, r9; Windows x64: rcx, rdx, r8, r9, a shadow
space of 32 bytes and the arguments past the fourth above it), with unit
tests of the encodings and a dump of every form for objdump. mod.rs,
the sequence per op: the frame in the interpreter's layout at every op,
every value boxed on the VM's stack; the VM, the frame's base, the
frame's address, the helpers' table, the base in bytes and the address
of the code object's count in callee-saved registers; the trivial ops
inline (Const, its three words copied from the code's table with a
retain unless plain or borrowed; Nothing; Load and LoadMove with
the borrowing of AU2, AU13 and AU17; Store, Pop and Dup with the
release or the retain through the helpers, as AT6 has it; the jumps; the
tag tests of JumpIfAbsent and JumpIfFailure; the Boolean branches
with the interpreter's crash on another value), every other op a call to
the helper the Cranelift tier calls for boxed operands; the stack's
length written after every op that changes the depth. The statuses as
the interpreter's arms treat them: a call, a construction, an update and
an expired deadline settle a failure (the landing of the innermost
handled region through rt_settle_handler, else rt_unhandled), while
an operator, a field, a text, a global, a range and an iteration push a
failure as a value and leave only on an interrupt (the Cranelift tier
sends such a status to its exit as an interrupt, which no program has
met). The tiers: Jit::entry gives the Cranelift code when it is ready,
else the template code, made at the first call and packed into one
executable chunk (CodeArena::place_packed: the pages a template lies
on writable while it is written, executable again before anything runs);
the template code counts the ops it runs as the interpreter counts them,
a basic block's length added to the code object's count as the block
starts, so that the same code objects are compiled at the same points as
before; past the threshold (the size times 100 with the compile thread,
8000 without) a back edge calls rt_osr, which asks for the Cranelift
code (compiled on the spot, or handed to the compile thread) and enters
it at the loop header when it is ready and has the entry, the frame
being in the layout the interpreter hands over; when it does not, the
count starts again. RENYI_NATIVE_TIER=template keeps everything on
templates, =cranelift turns the tier off; other targets than x86-64
keep the interpreter and the Cranelift tier. A defect of the Cranelift
tier met in the review of the promotion: a frame handed back to the
interpreter inside a handled region lost the region (the generated code
keeps the regions static, the interpreter on Vm::handlers), so a
failure after the hand-back crashed as unhandled where the interpreter
lands on the fallback; a deopt point now carries the regions open at it,
which rt_deopt pushes over the frame's floor (image format 7). The
tests: tests/template.rs (four programs on templates alone against the
interpreter: every source of a loop, every kind of call, updates in
place, a failure handled and passed on, a crash located, a recursion
past the depth of native frames), tests/promotion.rs (the factor 1,
synchronous, so that loops and calls are promoted at once: three code
objects on templates, three compiled, two running loops handed over),
tests/native.rs (the hand-back inside a handled region), the
conformance suite and the judges with RENYI_NATIVE_TIER=template, and
the self-check's output equal on templates. Not run: the Windows x64
convention, since neither this container nor CI has a Windows machine;
it was checked by reading (the argument registers, the shadow space, the
arguments past the fourth, the alignment, the callee-saved registers the
code uses and those it never touches), and its first run is cargo test
on the owner's machine, where tests/template.rs forces the tier. No
unwind tables are registered for template code, as for the Cranelift
tier's, so a panic inside a helper called from either aborts the
process. Two corrections came from the first measurement, both in the
design above: the first build added the whole code object's size to its
count at every entry, which made short functions that return early look
hot (on one hardware thread 88 code objects compiled where AU17's binary
compiled 54, 252 ms of Cranelift where it took 140, the self-check 6.6%
slower; on four 9.7%); and it placed every template in fresh pages of
its own, 564 mappings with every function at the same page offset, which
cachegrind does not see (it models no TLB) and which made the self-check
6.8% slower on one thread although the estimate fell 5.9%. Measured
against AU17's binary (d8ee092), both on one boot of a machine slower
than the one of AU17's entry by about 15%. By AT1's estimate under
cachegrind: the synchronous JIT run (RENYI_NATIVE_SYNC, the path of
one hardware thread, which the compile thread's timing does not make
vary) 13.99 to 13.12 billion cycles (-6.2%; 9.87 to 9.45 billion
instructions); the template code alone (RENYI_NATIVE_TIER=template)
14.73 against the interpreter's 17.55 (-16%; 11.12 against 12.60 billion
instructions); the interpreter unchanged (17.55 to 17.55); the image
9.71 to 9.78 and the run from the cache 10.68 to 10.74 (+0.8% and +0.6%,
the instruction misses up with the binary's layout, the machine code the
same); the default JIT run, with the compile thread, is no longer a
measure under cachegrind, whose serialized threads gave AU17's binary
12.94, 14.40 and 16.70 billion instructions in three runs. In
wall-clock, the two binaries alternating: on one hardware thread the
self-check -1.3% (best of fifteen) and -4.8% (best of seven, 1,992 to
1,897 ms), strings -3.0%, json_round_trip -1.9%, primes -0.6%,
records +0.2%; on two -3.1%, the benchmarks within 2%; on four the
median of twenty-five runs -1.1% and the best +1.9%, which is noise, the
benchmarks within 2%. The stage stays by AU1's rule (the cold run's
estimate falls) and by the owner's measure (no regression on any count
of hardware threads); the goal of AU18 is not reached: on one hardware
thread the JIT run takes 1,897 ms against the image's 1,335 (+42%, where
AU18 asked for 15%), and the templates alone 2,248 against the
interpreter's 2,347 (-4.2% in wall-clock where the estimate says -16%).
Where the gain goes: every call from template code goes through
rt_call, call_from_stack, run_top_frame, Jit::entry and
run_generated, where the interpreter's own calls push a frame and go
on in its loop, and the self-check makes 5.4 million calls; the hot
helpers (the field read, the retain, the release) stay calls; the
follow-ups that address both are put to the owner. (user)
AU20. The owner's answers of 2026-10-10 after AU19's measurement: (i)
the next steps of the round are both of the follow-ups put to the owner,
in this order: first the template tier's own (direct calls between
template functions, so that a call whose callee has machine code pushes
the frame and enters it without rt_call, call_from_stack,
run_top_frame and Jit::entry, and the field read through the site's
cache in place, as the Cranelift tier reads it), then the representation
items of AU1's step v (small texts inline, Int flattened into Value,
lists of unboxed Integers, values in registers across ops); (ii) a
Windows job in CI runs the VM's tests on every push, so that the Windows
x64 convention of the template tier runs (.github/workflows/ci.yml,
the job windows); (iii) the goal of AU18 stays the measure of the
follow-ups: the self-check's JIT run on one hardware thread within 15%
of its image; (iv) the template tier stays on by default, as measured.
The alternatives the owner declined: for (i), closing the round and
deciding the self-hosted front end (AU12), or the aarch64 encoder; for
(ii), verifying on the owner's machine alone, or the tier off on Windows
until it had run; for (iii), the goal relaxed to 25% or AT1's rule
alone; for (iv), the tier off until the follow-ups pay, or on only where
there is no compile thread. (user)
AU21. The template tier's follow-ups as built (decision AU20, its
first part): direct calls between template functions and the field read
in place. The entry table (Jit::entries, reached through
NativeState::entries) names per code object the machine code a call
enters: the Cranelift tier's trampoline once it is ready, else the
template, else nothing. Op::Call of a declared function in template
code checks the callee's entry and the depth of native frames, pushes
the callee's frame in place as Vm::push_frame_in_place pushes it (room
on the stack and for the record, the stack's length to the callee's
locals, its fresh locals Nothing, written in place up to four and by
rt_clear_slots past that, since a Cranelift callee may hand its frame
to the interpreter at its start, before its own prologue clears them;
the grant of Q1; the record), and calls the entry with a trampoline's
signature; the status decides the rest: the result where the arguments
were, a failure landing on the handler as the interpreter settles it;
the frame handed to the interpreter, which rt_finish_frame runs to its
end; an interrupt, after which rt_abandon_frame abandons the frame as
run_top_frame does. A callee without machine code, or a call at the
depth limit, goes through rt_call, which makes the callee's template
on its way; these rare paths lie after the body. Since a direct call no
longer passes Jit::entry, a template whose count is past the threshold
at its start asks rt_promote for its Cranelift code, and the entry
table names the trampoline once it is placed. LoadField in template
code reads the holder's type and tag against the site's cache entry and
copies the field with a retain, as the Cranelift tier reads it (AR4); a
miss calls rt_load_field, which fills the cache. The tests:
tests/direct.rs (the default factor, synchronous: a short callee
promoted while its caller stays on template code, then called with an
Integer past the machine word, which hands its frame back at the
trampoline's start; a callee that narrows the grant and one that does
not), with the template, promotion and native tests and the conformance
suite and the judges on the template tier. The Windows job of AU20
passed on its first push (CI run 78), tests/template.rs among its
tests, so the Windows x64 convention has run. The template code of the
self-check's run grows from 1.58 to 2.76 MB. Code format 7 (the four
helpers and the state's entries). Measured on one boot against AU19's
binary (bbea69b). By AT1's estimate under cachegrind: the synchronous
JIT run 12.87 to 11.71 billion cycles (-9.0%; 9.45 to 8.32 billion
instructions, -12.0%, the instruction misses up from 92 to 101 million
with the larger template code); the template code alone 14.50 to 12.18
(-16.0%; 11.12 to 8.79 billion instructions, -21.0%), now 29% below the
interpreter's 17.24 where AU19's was 16% below it; the interpreter and
the image, whose code the stage does not touch, 17.24 and 9.67 on this
boot. In wall-clock, the two binaries alternating, best of eleven: on
one hardware thread the self-check 1,595.9 to 1,398.8 ms (-12.4%),
primes -3.2%, records -1.2%, json_round_trip -0.7%, strings
+0.5%; on two the self-check -2.6%, the benchmarks -0.2% to -4.7%; on
four the self-check -1.3%, the benchmarks -1.0% to -2.1%. The stage
stays by AU1's rule (the estimate falls) and by the owner's measure (no
count of hardware threads loses). The goal of AU18 is nearer and not
reached: on one hardware thread the JIT run, alternating with the
image, takes 1,461.5 ms against the image's 1,162.9 (+25.7%, best of
fifteen; +21% by the estimate, 11.71 against 9.67), where AU19 left it
at +42%. (user)
AU22. The owner's answers of 2026-10-10 after the design study of the
representation items (the handoff's section "The representation items:
the design study"): (i) the order: small texts inline first (a text of
at most 15 bytes held in the value itself, two of them compared by the
generated code), then records and variants in one allocation (the
fields in the counted block after the header), each a stage measured
by AT1's rule; (ii) lists of unboxed Integers and Int flattened into
Value are deferred until a numeric program calls for them; (iii) the
three cuts the census found outside the list come first, each a stage
of its own: the guard bookkeeping skipped in a run whose grant guards
nothing, a fieldless variant read from the cache by the generated code,
one shared empty list; (iv) the goal of AU18 is measured on the run
part: the self-check's JIT run on one hardware thread, without the
front end's compilation of the checker program, within 15% of its
image; the front end's speed is an item of its own. Why (ii): no
program of the five makes a list of Integers worth unboxing (primes
counts over ranges; the self-check makes 3,249 such lists of 741,923);
the flattened Int alone estimates below 1% of the self-check, whose
Integers live in registers on the Cranelift tier, and it pays mainly as
the step to a 16-byte Value, which would cap the inline texts at 7
bytes. Why (iv): of the gap the study measured (the JIT run 1,456 ms on
one hardware thread, the image 1,212, +20%), the front end that
compiles the checker program, 24,000 lines, takes 155 ms, about two
thirds; a representation item makes the run and the image faster alike
and so widens the ratio as stated, while an agent's script of a few
hundred lines spends a few milliseconds in the front end and a repeated
run loads its image from the cache (AU10). The run part is the time
from the program loaded to the end of main, which RENYI_NATIVE_REPORT
now prints after the JIT's report for the JIT run and for the image
alike; by the study's numbers it stands about 7% above the image. The
alternatives the owner declined: for (i), records first, the texts
alone, values in registers first; for (ii), the flattened Int after
the texts and the records, or both items as AU1 listed them; for
(iii), the cuts after the representation items, or none; for (iv), the
goal kept as stated with a round on the front end's speed after the
representation items or in a round of its own, or AT1's rule alone.
(user)
AU23. The first cut of AU22 as built: the guard bookkeeping skipped
in a run whose grant guards nothing. The VM keeps guarding, set by
begin_run when the grant (with a sandbox's) carries a guard and never
cleared, so that a VM that runs examples and tests one after the other
follows the data again from the first guarded one; while it is false no
value carries origins (only Value::guarded with a guard's bit makes
one), and the constructions of the interpreter and of the generated
code's helpers (MakeList, Construct and ConstructVariant;
rt_make_list, rt_construct and rt_construct_variant) take their
operands as they are, without plain_all and without guarded; a
primitive's result is wrapped only when there are origins to add
(run_native). The first build took another way: the slow paths of
guarded, into_plain and plain_all moved out of line and their fast
paths inlined everywhere. It ran fewer instructions on every program
(the self-check's synchronous JIT run -2.0% by the estimate, records
-3%) and was slower in wall-clock on records (+3% on the benchmark,
+4% on the same program with two million points), which a build with
guarded kept out of line put back: the inlined moves of a 24-byte
value cost what the count of instructions does not show (cachegrind
models no store forwarding). Calling no wrapper at the call sites, as
built, gained instead (the two-million-point program -10.8% on one
hardware thread). The test: tests/guards.rs,
a_guard_after_a_run_without_one_follows_the_data_into_a_record (a test
without a guard, then one that writes the text of a record built from
the secret; with the flag never set the record is not tagged and the
text leaks, as the test was checked to show), beside the guard tests
that run with the flag set. Measured on one boot against AU21's binary
(fb15b1c). By AT1's estimate under cachegrind: the synchronous JIT run
11.71 to 11.44 billion cycles (-2.4%; instructions -2.8%), the template
code alone 12.18 to 11.91 (-2.2%), the image 9.67 to 9.35 (-3.3%), the
interpreter 17.24 to 17.24 (instructions -0.8%, its branch misses up
with the layout of its loop). In wall-clock, the two binaries
alternating with the order swapped every turn, best and median: on one
hardware thread the self-check -1.0% and -2.3%, records -7.0% and
-5.9%, strings -1.0% and -1.5%, primes -1.0% and -0.3%,
json_round_trip +0.4% and +1.4%; on two the self-check -2.0% and
+0.7%, records -9.6% and -12.0%, the others within 1.5%; on four the
self-check -6.5% and -7.2%, records -11.7% and -10.6%, strings -2.6%
and -5.0%, json_round_trip and primes within 2%. The stage stays by
AU1's rule and by the owner's measure. (user)
AU24. The second cut of AU22 as built: a variant without fields read
from the cache in place by the generated code. The VM keeps the
variants without fields it has built (decision AG6) in a vector with a
fixed layout, Vm::unit_variants, Nothing in a slot until its
variant is built; vm::unit_slot gives a variant's slot from the
program's types as the VM lays them out. ConstructVariant of a variant
without fields reads the slot's tag in both tiers: once built, the value
is copied onto the stack and the count of its block, the block's first
word, raised by one in place; the first time, rt_construct_variant
builds and keeps it, on a path after the body in template code. Code
format 8. The tests: tests/native.rs and tests/template.rs,
variants_without_fields_are_copied_from_their_slot_and_counted (3,000
lights cycled and kept in a list, compared and matched, and 2,000
shapes with and without fields, against the interpreter; without the
raised count the template test crashes, as it was checked to), with the
conformance suite and the judges on the template tier. Measured on one
boot against AU23's binary (2abc849). By AT1's estimate under
cachegrind: the synchronous JIT run 11.44 to 11.29 billion cycles
(-1.3%; instructions -1.7%), the template code alone 11.91 to 11.71
(-1.7%), the image 9.35 to 9.21 (-1.5%), the interpreter 17.24 to 17.21
(-0.2%). In wall-clock, alternating with the order swapped every turn,
best and median: on one hardware thread the self-check -3.9% and -2.3%,
the benchmarks within 1% but records (-0.8% and -2.8%) and strings
(+0.0% and -5.1%); on two the self-check -1.0% and -0.5%, the
benchmarks within 1.2%; on four the self-check +0.0% and +0.9%, the
benchmarks within noise (records +2.3% and -0.8%, strings -0.6% and
+3.0%). The stage stays by AU1's rule and by the owner's measure. (user)
AU25. The third cut of AU22 as built: one shared empty list.
Value::list of no items gives a list that every such list shares, kept
per thread as the ASCII table keeps the one-character texts; a list
appended to later is copied out of it first, as any list held twice is
(Rc::make_mut). No test is new: the corpus, the conformance suite
and every test that builds a list from [] and appends to it run the
copy. Measured on one boot against AU24's binary (f26c1ca), the cut is
neutral. By AT1's estimate under cachegrind: the synchronous JIT run
11.292 to 11.289 billion cycles (-0.03%; instructions -0.3%, the branch
misses up 1.8 million, of the copies the shared list costs where a list
made empty is appended to, which most of the self-check's are: the
saving is the lists that stay empty), the template code alone level
(+0.04%), the image level (-0.04%), the interpreter -0.3%. In
wall-clock the self-check moved between -3.6% and +1.0% (best of
fifteen and of twenty-one) on one hardware thread, +0.2% on two and
-2.7% on four, and strings, which makes no empty list and runs the
same instructions on both binaries, +3.3% on one thread over sixty-one
runs: the layout of the binary, which every change moves. The cut stays
by AU1's rule (the estimate falls, if barely) as the smallest of the
three; the census's estimate of 0.4% assumed lists that stay empty.
(user)
AU26. The first representation item of AU22 as built: small texts
held in the value. A text of at most 15 bytes is Value::SmallText, a
tag of its own (20, appended so that no other tag moves) with the length
at the payload and the bytes after it, zero to the end of the value; a
longer one stays Value::Text. Value::text and Value::character
choose by the length, so that a text has one form for its characters,
and every reader takes either: as_text, natives::text and
plain_text, the renderer and its ordering, the comparisons, the
concatenation, the JSON, the bytecode file and the image's program
(which write a text constant as before, so that the judges stay equal).
Equality compares the characters, and a text hashes as its characters
in either form. The ASCII table of Value::character goes: a character
is a small text. In both tiers, is and is not on operands of which
the checker noted one a Text compare two small texts in place (both
tags read, the sixteen bytes past them compared as two words, the
Boolean written, nothing to release); anything else takes rt_compare
as before. Code format 9. The first build copied a short text with
copy_from_slice, which called memcpy and memset for every
character made: strings ran 1.1% more instructions and lost 7% in
wall-clock. The copy now reads and writes two overlapping words, halves
or quarters as the length asks, without a call, and a character is
encoded straight into the value. The tests: in value.rs, a short text
at every length from 0 to 15 and the characters of one to four bytes,
equality and hashing across the two forms, and the layout test with the
new tag; in tests/native.rs and tests/template.rs,
texts_held_in_the_value_compare_in_place_and_others_as_before (texts
of 1 to 28 bytes and a two-byte character compared both ways and
ordered, the characters of a line against a constant, against the
interpreter; with the answer inverted in either tier the test fails, as
it was checked to); the conformance suite and the judges on both tiers.
Measured on one boot against AU25's binary (1c27240). By AT1's estimate
under cachegrind: the synchronous JIT run 11.29 to 10.46 billion cycles
(-7.4%; instructions -5.6%, the indirect branch misses 67.8 to 47.1
million with the calls to rt_compare gone), the template code alone
11.71 to 10.64 (-9.1%), the interpreter 17.17 to 16.15 (-5.9%), the
image 9.21 to 8.38 (-9.0%). In wall-clock, alternating with the order
swapped every turn, best and median: the self-check -7.8% and -5.3% on
one hardware thread, -7.4% and -3.9% on two, -6.8% and -7.0% on four;
the benchmarks within 3% either way (strings +2.8% and +1.1% on one
thread with 6.9% fewer instructions, the layout again). The study had
estimated 4 to 5%. The stage stays by AU1's rule and by the owner's
measure. (user)
AU27. The second representation item of AU22 as built: records and
variants in one allocation. A record or a variant is a Composite, a
thin pointer to one counted block that holds the count, the number of
fields, the type, the tag (a record's usize::MAX) and the fields
themselves; Deref gives its Shape (the type, the tag and the fields
as a slice: a type with a slice tail), so that the code that read
record.ty and record.fields reads them as before. A clone raises the
count in place, a drop lowers it and the last holder frees the block out
of line, as an Rc does; make_mut copies the block before an update
unless it is held once, get_mut gives it when it is. The type and the
tag lie where the former Rc held them (16 and 24 bytes from the
block's start) and the fields start at 32, so that a field read in
either tier adds the index to the block's address where it first loaded
a pointer to the fields. Construct and ConstructVariant of a type
without a refinement make the composite from the operands on top of the
stack, moved into the block with no vector between
(Vm::construct_from_top and construct_variant_from_top); the guarded
path, the refined types and the natives build from a vector as before,
its values moved into the block. Code format 10. Two corrections came
from the profile of the first build, which ran no fewer instructions
than AU26's (+0.1%) though the allocations fell: the composite's drop
was a call at every lowered count where Rc lowers it in place and
calls only to free (the fast path is now inline, Composite::free out of
line), and its clone checked the count against usize::MAX with a call
to abort, which gave every clone of every value a frame of its own
(the clone is now a plain increment, as the generated code raises a
count, with a debug assertion in its place). The tests: in value.rs,
the block's layout (the count, the length, the type, the tag and the
fields where the generated code reads them; the count raised and
lowered by a clone and its drop) and
a_composite_is_copied_before_an_update_unless_it_is_held_once
(make_mut on a shared and on a unique block, get_mut, from_top, an
empty composite); in tests/native.rs and tests/template.rs,
records_in_one_block_are_built_read_copied_and_compared (2,000
segments of two points with texts long and short kept in a list, a
point copied by with while shared and compared, variants with fields
matched, against the interpreter; with the clone's count not raised the
test aborts, as it was checked to); the conformance suite and the judges
on both tiers. Measured on one boot against AU26's binary (5be5e60). By
AT1's estimate under cachegrind: the synchronous JIT run 10.46 to 9.97
billion cycles (-4.6%; instructions -3.8%), the template code alone
10.64 to 10.18 (-4.4%), the interpreter 16.15 to 15.81 (-2.1%), the
image 8.38 to 7.87 (-6.1%). In wall-clock, alternating with the order
swapped every turn, best and median: the self-check -10.5% and -8.3% on
one hardware thread, -3.9% and -2.0% on two, -4.4% and -6.6% on four;
records -10.5% to -12.9%; json_round_trip between -0.7% and +4.6%,
whose records come from the decoder's vectors and are copied into their
blocks (0.9% more instructions); strings and primes within 2% at the
best. The stage stays by AU1's rule and by the owner's measure. (user)
AU28. The owner's answers of 2026-10-10 after AU27: (i) the next
stage is the retain and the release in place in template code: a tag
test and a raised count where a copy of a value calls rt_retain_at
today, a lowered count with a call only when it reaches zero where a
dead value calls rt_drop_at, judged by AT1's rule (the template code
grows, and AT6 found calls cheaper than counts in place on the
Cranelift tier); (ii) after it, as a small stage, the natives build a
record in its block directly (the decoder of std.json first), which
takes back the 0.9% of instructions AU27 cost json_round_trip; (iii)
the front end's speed is a round of its own after this one. The
alternatives the owner declined: for (i), the hottest natives in place
(List.at on a small Integer, Text.contains on small texts), the
compile cost on one hardware thread, or the round closed and the
self-hosted front end decided (AU12); for (ii), before the next stage,
or not at all; for (iii), within this round, or not planned. (user)
AU29. The first item of AU28 as built: the retain and the release in
place in template code. Where a copy of a value called rt_retain_at,
the code reads the tag and tests its bit in a mask of the tags whose
payload points at a counted block (RC_TAGS, the composites of AU27
among them) and of the Integer's: a value with neither holds no count
and a short jump skips the rest; a counted block has its first word,
the count, raised in place; an Integer goes out of line, where a big
one raises its block's count and a small one nothing. Where a dead
value called rt_drop_at, the same test lowers a counted block's count
in place, and only a count that reaches zero goes out of line, where it
is raised back to one and the helper drops the value, which frees the
block and what it holds; a big Integer goes to the helper, a small one
nowhere. The assembler has two forms more, bt of two 32-bit
registers and the conditional jump with a one-byte offset, patched with
the others when the code is finished and refused there when its target
lies out of reach. An image holds no template code: the code format
stays 10. Why the template tier takes what AT6 refused the Cranelift
tier: there the call replaced AR4's generic sequence, which tested the
tag's bit, the big Integer and both payload words at every site; here
the sequence tests one bit and skips, and the call it replaces went
through the helpers' table, so that the indirect branches the model
counts as missed fell from 47.3 to 28.9 million on the template code
alone. The template code grew: the self-check's 564 code objects (30,602
ops) took 2,789,448 bytes and take 3,480,698 (+24.8%; 91 to 114 bytes
per op), and the instruction misses rose 70.3 to 84.5 million; AT1's
estimate weighs both. The tests: in x64.rs, the encoding of bt and
of a short jump over two bytes, and a short jump past its reach
refused; in tests/template.rs,
counts_raised_and_lowered_in_place_free_the_last_and_spare_big_integers
(3,000 records with a text past sixteen bytes and an Integer past the
machine word, a third kept in a list, the last Integer kept across the
loop, against the interpreter; with the raise or the lowering taken out
the test aborts, as it was checked to); the conformance suite and the
judges on both tiers. Measured on one boot against AU27's binary
(14ce593). By AT1's estimate under cachegrind: the template code alone
10.18 to 9.65 billion cycles (-5.2%; instructions -4.1%), the
synchronous JIT run 9.97 to 9.78 (-1.9%; instructions -1.7%), the
interpreter 15.81 to 15.83 and the image 7.87 to 7.90 with their
instructions equal to a hundredth of a percent (the binary's layout).
In wall-clock, alternating with the order swapped every turn, best and
median: the self-check -5.6% and -7.6% on one hardware thread, -0.8%
and -1.8% on two, -3.6% and -6.0% on four; the benchmarks between
-4.2% and +3.2%, faster in 18 of their 24 numbers (json_round_trip, which
the next stage takes on, between -1.9% and +3.2%). The run part of AU22, the JIT run over the image on one
hardware thread, alternated eleven times and measured twice: +9.7% and
+9.1% at the best, +7.7% and +3.0% at the median, where AU27's binary
measured +11.0% and +13.6%, +12.2% and +19.7% on the same boot: the
goal of AU18 (within 15%) is reached on this boot at the best and the
median, the JIT run part 1,071.9 to 1,035.3 ms at the best (-3.4%). The
stage stays by AU1's rule and by the owner's measure. (user)
AU30. The second item of AU28 as built: the decoder of std.json
builds a record in its block. The fields of a record or a variant are
decoded onto the VM's stack in their order (decode_fields) and moved
from there into the block (Composite::from_top), as the bytecode's
constructions move theirs since AU27, with no vector between; a type
with a refinement to check takes its fields off the stack into a vector
and goes through construct or construct_variant as before, and so
does a variant without fields, which stays shared (AG6). A field that
does not decode, or an interrupt, cuts the stack back to the height it
had, and decode asserts in a debug build that it leaves the stack as
it found it. The natives that build a record from a vector of known
length (the library's records and errors, the rows of sqlite.query,
the nodes of a JsonValue) keep it: no measured program spends on
them. Before AU27 a decoded record kept the decoder's vector and put
an Rc around it, two allocations; AU27 made them the vector and the
block, with a copy between; the block is now the only one. The decoder
calls Composite::from_top itself rather than Vm::construct_from_top,
for a reason found by measurement. The first build called the VM's
function, which LLVM had inlined into its two callers (the
interpreter's loop and rt_construct, the generated code's helper)
and kept out of line once the decoder made a third: the self-check's
synchronous JIT run executed 47.6 million instructions more (0.7%), the
calls the profile put on the two functions. The second build forced
the inlining everywhere: the rows of the generated code came back
level, but the interpreter's loop compiled otherwise and ran 1.2% more
instructions with 43% more branch misses. The third leaves the VM's
functions with their two callers, and the interpreter's loop and the
helpers are the machine code of AU29, to the byte in size;
Composite::from_top, construct and construct_variant were out of
line in every build, so that a caller more changes nothing. The tests:
in tests/semantics.rs,
decoded_records_are_built_in_their_block_and_keep_their_refinements
(a record and a variant with a refined field decoded where the field
holds and where it does not, the variant refused after the record
beside it was decoded, a field that does not decode in the middle of a
record, the runs after each reading their values whole, interpreted and
not; with the refinements skipped the test fails, as it was checked
to); the assertion's power check (with the cut taken out of
decode_fields, json_paths of the conformance suite aborts on it, as
it was checked to); json_paths itself on both tiers; the judges. No
test ran the refined records of the decoder before: the corpus's two
programs that decode one (config.ry, active_users.ry) do it in
functions no example or test calls. Measured on one
boot against AU29's binary (8b642fd). By AT1's estimate under
cachegrind on json_round_trip: the synchronous JIT run 1.067 to 1.033
billion cycles (-3.2%; instructions 938.4 to 901.3 million, -3.9%), the
template code alone -3.3%, the interpreter -3.1%; on the self-check
every row with its instructions equal to a hundredth of a percent (the
estimates 0.1% to 0.9% lower with the binary's layout). In wall-clock,
alternating with the order swapped every turn, best and median:
json_round_trip -2.0% and -1.9% on one hardware thread, -1.1% and
-7.2% on two, -1.1% and -1.3% on four; the self-check, whose
instructions are equal, within the noise (+1.1% and +0.4%, -0.4% and
+0.9%, +0.7% and -2.3%); the other benchmarks between -5.8% and +2.8%.
The stage stays by AU28's measure: it takes back more than the 0.9% of
instructions AU27 cost the benchmark. By AU1's rule alone it is level:
the self-check's estimate falls only with the layout, and the
benchmark's gain is below the 5% of the rule's second branch. (user)
AU31. The owner's answers of 2026-10-10 after AU30: (i) the next
stage is AU29's sequence on the Cranelift tier, the retain and the
release in place in the code Cranelift makes where AT6 kept the calls
to rt_retain_at and rt_drop_at (AT6 had measured them against AR4's
longer generic sequence), judged by AT1's rule; then the hottest
natives in place in the generated code of both tiers (List.at with a
small Integer index, Text.contains, List.contains), a stage of its
own; (ii) the goal of AU18 is called met only when a measurement on
another boot of the container (a later session, after a restart) finds
the run part within 15% again; (iii) the natives that build a record
from a vector (the rows of sqlite.query, the library's records and
errors, the nodes of a JsonValue, which also look their type up by
name for every node) stay as they are until a profile points at them;
(iv) the front end's round, when it opens, starts with a study: the
profile of the parse, the check and the compile on the self-check and
the corpus, with a cache keyed by the sources' hash that skips the
front end among the candidates, and the owner orders the stages from
it. The alternatives the owner declined: for (i), the hottest natives
first, the compile cost first, or the round closed for the front end's;
for (ii), the goal called met on this boot's two measurements, or a
stricter measure (the median within 10%, or three boots); for (iii),
the JsonValue nodes now, or every such native as one stage; for (iv),
the cache keyed by the sources first, or the checker's hot spots
directly. (user)
AU32. The first item of AU31 as built: AU29's sequence on the
Cranelift tier, and the compile thread stopped at the end of a run.
In the code Cranelift makes, retain and release test the tag's bit
in COUNTED_OR_INTEGER (now one constant in value::layout for both
tiers): a value with neither goes on; a counted block has its first
word, the count, raised or lowered in place; an Integer goes to a cold
block, where a small one holds no count, a big one's count is raised
in place on a retain and the value goes to rt_drop_at on a release; a
count lowered to zero goes to a cold block that raises it back to one
for rt_drop_at, which frees the block, the one call a release has.
rt_retain_at is gone from the helpers: code format 11. The JIT's
compile thread, when the VM is dropped, stops after the compilation
under way, where closing its channel alone let it compile every
request still queued before the process could end. Four builds were
measured against AU30's binary (81aa432) on one boot, all four in AT1's
rows. (a) A release with two calls, one for the last reference and one
for a big Integer: the machine code of the self-check's image 5.73 to
7.69 MB, the synchronous JIT run's instructions -0.2%, the image's
-5.0%. (b) Every Integer through the helpers, no test of a small one in
place: 7.43 MB, the image's estimate 1.0% behind (a). (c) As (a) with a
big Integer's retain through rt_retain_at: 7.91 MB and more
instructions than AU30 on the JIT run, since a call in a cold block
costs the register allocation of the whole body. (d) As (a) with the
release's two calls one: 7.65 MB (+33.6%; 5,976 to 7,986 bytes of body
per code object) and 0.2% fewer instructions than (a); it is the stage.
AT6 had kept the calls against AR4's sequence, which tested the big
Integer and read both payload words at every site; this one tests one
bit and skips. The compile thread's correction came from the
measurement: with (d)'s code, larger by a third, the time from the end
of main to the end of the process on two hardware threads rose from
187 to 324 ms, the thread compiling its queue for code nothing would
run; the comment on Worker's drop had said that only the compilation
under way finishes. The tests: in tests/native.rs,
counts_raised_and_lowered_in_place_free_the_last_and_spare_big_integers
(records with long texts and a weight past the machine word as a maybe
Integer, boxed, so that its copies are counted in this tier's code,
which keeps an Integer in a register and hands a big one to the
interpreter; against the interpreter; with the counted block's raise
taken out the test aborts, with the big Integer's it crashes, as it was
checked to); the conformance suite and the judges on both tiers. By
AT1's estimate under cachegrind, against AU30's binary: the image 7.89
to 7.53 billion cycles (-4.6%; instructions -5.1%, the indirect
branches missed -47%, the instruction misses +31%); the synchronous JIT
run level within the layout's spread, which two builds each of (a) and
(d), the generated code the same within each pair, put at -0.4% and
+0.1%, -0.3% and +0.4% (its instructions -0.2% and -0.4%; the template
row, whose code did not change, moved +1.1% in the last); the
interpreter level; strings -2.2% and records -3.8% on the JIT run. Cranelift's work on the 54 code objects of the synchronous
run: 44.0 to 57.0 thousand instructions of IR (+30%) in 3.3 to 6.4
thousand blocks, 76-90 to 84-93 ms. In wall-clock on the self-check,
alternating fifteen times: the compile thread's correction alone level
on one hardware thread, -6.3% and -5.3% (best and median) on two, -4.8%
and -3.9% on four; the counts on top of it -2.7% and -3.7% on one,
-5.4% and -8.1% on two, -10.8% and -9.5% on four, the run part of AU22
-5.0%, -7.2% and -13.1% at the best. The stage against AU30's binary,
alternating with the order swapped every turn, best and median: the
self-check -9.3% and -3.0% on one hardware thread, -13.5% and -15.5% on
two, -9.4% and -14.0% on four; strings between -13.1% and -16.0%,
records between -3.8% and -6.9%, json_round_trip and primes
within the noise (-3.7% to +5.1%). The run part of AU22 on one hardware
thread, eleven alternations: the image 929.7 to 776.8 ms at the best
(-16.4%), the JIT run 1,009.3 to 991.5 (-1.8%), so that the JIT run over
the image went from +8.6% to +27.6% (+8.2% to +28.7% at the median):
the image gains everywhere, the JIT run only where Cranelift's code
runs, and its code is on templates for most of the run. AU18's goal
moves away by a stage that makes both faster; AU31's measurement on
another boot takes it as it is now. The stage stays by AU1's rule: a
benchmark gains more than 5% (strings 13.1% to 16.0% in wall-clock)
while the self-check's estimate moves within its spread. (user)
AU33. The owner's answers of 2026-10-10 after the study of the typed
calls: (i) List.at in place in the generated code of both tiers reads
the list's items through the layout of Vec<Value> probed when the VM
starts: the offsets of the pointer and of the length within the vector
are kept in the VM's native state and loaded by the code, which holds
no assumption about the layout, so that neither the code nor an image
depends on how the compiler laid the vector out, and a test holds the
probe; (ii) Text.contains and List.contains each get a lean helper
that the generated code calls directly with its operands' place and
that answers a Boolean, with no typed entry's dispatch, no loop over
the arguments and no memory check, the search staying in Rust; (iii)
the general path of a typed call becomes lean as a stage of its own
after this one: the generated code releases the arguments the call does
not borrow (in place, AU29 and AU32) and pushes the answer itself, and
the entry is called through a thin shim per kind of answer; (iv) AU18's
goal is met with AU30's binary, whose run part measured within 15% of
the image on two boots (+9.1% and +7.6% at the best); the ratio is
recorded in every entry from now on and is no longer a goal, the JIT
run measured by AT1's rule and wall-clock against the stage before.
The study, on AU32's binary: the self-check's synchronous JIT run made
2.77 million typed calls, List.at 1.39 million of them (its own work
46 instructions a call, the path around it about 150: the dispatch of
rt_call_typed about 66, typed_value_answer about 83), Text.contains
0.66 million (108 and 66), List.contains 0.16 million (290 and 66),
the others 0.56 million; List.at in place would be 15 to 20
instructions. On the boot after AU32's, the run part measured +25.2%
for AU32's binary (its image 20% faster than AU30's, its JIT run 7%)
and +7.6% for AU30's. The alternatives the owner declined: for (i), the
offsets compiled into the code with the image's header recording them,
or the list in a vector of fixed layout; for (ii), small texts and a
one-byte needle in place, or the two left as they are; for (iii), the
protocol within this stage, or not before a new profile; for (iv), the
ratio kept as a goal, or a fixed reference (the run part within 15% of
AU30's image). (user)
AU34. The stage of AU33 (i) and (ii) as built: List.at in place,
Text.contains and List.contains through lean helpers.
layout::list_layout finds, on a vector of known address, length and
capacity, where a list's block keeps the address of its items and their
count, counted from the start of the Rc's allocation, and the VM keeps
both offsets in its native state (list_items, list_len); a build
whose vector is not three such words has no List.at in place. A typed
call carries the native it may do in place (CallKind::Typed { kind,
in_place }, InPlace), named by the prelude's functions
(natives::prelude::in_place), which no other extension declares. In
both tiers, List.at on a list and a small Integer loads the two
offsets, compares the index with the count unsigned, copies the item
with one more reference (the sequences of AU29 and AU32) or writes
Nothing, and releases the list after the copy unless the call borrows
it, since the release may free it (the template code, which has no
register to hold the item across the release, copies it over the
index's operand first); a guarded or big operand, or a failure among
the items, takes the general path with the operands untouched.
rt_text_contains and rt_list_contains take the operands' place and
the mask of those the call borrows, and answer 0 or 1 from the typed
entry with the others released, or DECLINED (2) with nothing touched,
when the general path follows. Code format 12. After the stage the
self-check's synchronous JIT run makes 0.56 million calls through
rt_call_typed where it made 2.77 million, and 0.37 million through
typed_value_answer where 1.76; a lean helper's own work is 20
instructions a call where the dispatch was about 66. The tests: in
value.rs, a_list_s_items_and_length_lie_where_the_probe_finds_them
(lists of 0 to 40 items read through the offsets); in tests/native.rs
and tests/template.rs,
list_items_read_in_place_and_contains_through_lean_helpers (items of
every kind at every position and past both ends, lists held by slots
and lists made for the call, an index past the machine word on the
general path in a function of its own, against the interpreter; with
the item's retain taken out the test aborts on both tiers, with the
helpers' answer forced false it fails on both, as it was checked to);
the conformance suite and the judges on both tiers. The first test
program held the index past the machine word in main, whose frame the
Cranelift tier then handed to the interpreter for the whole loop, so
that its check passed without the retain; the index moved to a function
of its own. Measured on the boot after AU32's, against AU32's binary
(7353f11) measured again on it (its rows within 0.01% of the earlier
boot's). By AT1's estimate under cachegrind: the synchronous JIT run
9.76 to 9.30 billion cycles (-4.7%; instructions -4.2%), the template
code alone 9.67 to 9.16 (-5.3%), the image 7.53 to 7.03 (-6.7%;
instructions -5.8%), the interpreter level. The machine code of the
self-check's image +0.7%, its template code +0.6%. In wall-clock,
alternating with the order swapped every turn, best and median: the
self-check -6.4% and -0.3% on one hardware thread, -2.1% and -4.8% on
two, -5.2% and -6.4% on four; the four benchmarks, which call the three
natives little, within the noise (-2.7% to +4.8%). The run part of AU22
on one hardware thread: the JIT run 1,008.0 to 927.4 ms at the best
(-8.0%), the image 789.2 to 773.6 (-2.0%); the ratio, recorded as AU33
says, +19.9% at the best and +23.4% at the median. The stage stays by
AU1's rule. What the general path still carries: 0.56 million calls of
the self-check (List.last 0.18 million, List.join 0.16, List.length
0.07, the rest under 0.03 each), whose dispatch and value answers cost
about 63 million instructions, 0.9% of the run: the most the stage of
AU33 (iii) can take back. (user)
AU35. The owner's answers of 2026-10-10 after the progress report:
(i) the typed round closes, its three goals met (bench/strings.ry
past CPython, the self-check's estimate on the JIT run 37% under AT7's
14.83 billion cycles where a quarter was asked, AU18's ratio met with
AU30's binary on two boots, AU33); the general typed path of AU33 (iii)
is not built, a candidate worth at most 0.9% of the self-check; the
front end's round opens with the study of AU31 (iv); (ii) the binary
keeps the Rust front end, the judges keep the compiler written in Renyi
equal to it, and from now on every entry that measures speed records
the ratio of the Renyi compiler's time to the Rust front end's on the
same file with the same binary (checking, parsing and compiling
compiler/bodies.ry); the switch is decided when the ratio is within
3×, the threshold the question proposed. The report the answers
followed, measured on one boot, best of seven on four hardware threads:
the self-check (the Renyi checker on compiler/bodies.ry) 1,854 ms on
AU10's binary and 1,052 on AU34's (-43%), 1,415 and 834 from the image
(-41%), 2,095 and 1,632 on the interpreter (-22%); session 12 alone,
AU27's binary against AU34's, -13.0% on one hardware thread and -18.0%
on four at the best; the benchmarks against CPython on the JIT run,
primes 41 ms against 485 (11.8 times as fast), records 36 against
152 (4.3), json_round_trip 93 against 151 (1.6), strings 68 against
73 (1.1, where AU10's binary took 82, 0.9); the front ends on
compiler/bodies.ry (7,774 lines and what it imports): checking 77 ms
with the Rust front end, 820 with the Renyi checker from its image and
1,101 on the JIT run (10.6 to 14.2 times), parsing 78 and 348 (4.4),
compiling 103 and 1,132 (11.0), where session 10 had measured checking
at 0.083 s and 1.87 s (22.5 times). What renyi build is, as the report
stated it: ahead-of-time machine code for every function of a program
in an image that runs in the Renyi runtime, the executable of
build --exe that binary with the image appended, the image cache
that makes every later run of a program load its code, the front end
still run before a hit. The alternatives the owner declined: for (i),
the append's copies first, or the general path as AU33 ordered; for
(ii), an opt-in switch to an image of the Renyi compiler built into the
binary, the switch for compile and build only, or the switch for
every command now. (user)
AU36. The owner's answers of 2026-10-10 after the front end's study:
(i) the Rust front end first, in the order A0 (every file parsed once:
the resolver's trees handed to the check, and check without a parse
of its own of the main file), A1 (the parser's token comparisons by
variant, inlined, and advance without the clone where the token is
dropped), A4 (the library's fixed cost: the prelude and the modules a
program imports declared, the item lists shared rather than cloned),
then A2 (a cache keyed by the sources, which skips the front end when
every file a compile read hashes as it did); (ii) then the compiler
written in Renyi and the VM under it: B5 (a comparison of two boxed
values the checker typed Integer, inline in both tiers), B1 (the lexer
rewritten for speed with the library as it is), B2 (the parser's
keywords and symbols compared by tag, no record built per look) and B3
(small functions inlined on the Cranelift tier), the library unchanged;
(iii) the gate of AU35 (ii) is measured against the Rust front end of
AU34's binary (commit 44782aa) on the same boot, a fixed reference,
with the ratio against the same binary recorded beside it; (iv) before
the compiler's sources change, a copy of today's compiler goes under
bench/ as the program of AT1's measure, which stays fixed while
compiler/ improves; the ratio of (iii) is taken on compiler/. The
study the answers followed is the handoff's section "The front end's
round", on AU34's binary: renyi check compiler/bodies.ry (nine files,
13,280 lines) runs 437 million instructions, 314 million of them in the
parse, which parses every file twice and the main file three times
(the resolver for the imports, the check, and diagnose); the token
comparisons are calls (TokenKind::eq, 18% of the run); the library's
fifteen declaration files are parsed and declared at every start, half
of an empty program's check; the Renyi checker runs 4.99 billion
instructions on the same files, its lexer 56 times the Rust lexer's,
its parser 17 times, the rest 15 times, and a scan in one loop over the
same characters costs a sixth of the lexer as written. One operation of
each kind the compiler does, in instructions from an image: a call 96,
a character read from a list and compared 135, the lexer's is_lower
370, a record of three fields made and read 440, the parser's step on a
shared cursor 1,340, its test for a keyword 870, an append to a list
held once 370, where compiled Rust spends from none to a few. The
estimates: A0 and A1 together check -52% and the self-check's front
end -34%; A2 hello from 7.2 to about 5 ms; B1 and B2 the Renyi
checker from 850 to about 500 to 550 ms; the gate of (iii) about 215 ms
on that file. The owner chose, for (ii), the option "the same, plus
B3" after an option that added a text method answering code points;
the entry reads it as B5, B1 and B2 with B3 and without the method,
which B1's measure can bring back as a question. The alternatives the
owner declined: for (i), the cache first or the compiler in Renyi
first; for (ii), the three stages without B3, with the code point
method, or no change to the compiler in Renyi in this round; for (iii),
the same binary as AU35 (ii) states it, or no speed work on the Rust
front end before the switch; for (iv), a measure that follows the
compiler. (user)
AU37. Every file parsed once by the Rust front end (stage A0 of
AU36). The resolver (renyi_package::resolve) parses each file as the
check takes it (parse_file: a bound module's declarations, any other
file as a module) and keeps the trees beside the files
(Resolved::trees); the check declares the modules from them
(check_parsed_project_in; check_project_in parses and calls it);
renyi check parses the main file once, reports its errors alone as
before, and otherwise hands the tree to the resolver (resolve_parsed)
and checks what it returns (check_resolved_in); compile_file, which
every command that compiles calls, and the package commands' index check
the resolver's trees. The resolver reads a bound module's imports from
its declarations' parse, as the compiler in Renyi does (project.ry),
where it parsed the text as a module before: the imports are the same,
the mode changing the bodies only. The commands that check canonical
texts (index, tools) and the resident world keep their own parses.
The outputs are unchanged: the gates passed, the judges among them.
Measured on one boot against AU34's binary, callgrind for the
instructions and the best of nine alternating runs for the times:
renyi check compiler/bodies.ry 437.3 to 243.5 million instructions
(-44.3%), 72.1 to 47.3 ms (-34.5%); check compiler/checker.ry 561.0
to 371.3 million (-33.8%), 91.8 to 69.8 ms (-24.0%); compile
compiler/checker.ry 989.9 to 801.5 million (-19.0%), 155.2 to 132.6 ms
(-14.6%); the thirty examples checked one at a time 208.3 to 198.1 ms
summed (-4.9%); an empty program and hello within noise (-0.6% and
-1.5% in instructions: the library's fixed cost, which is A4's).
AT1's rows on the same boot (AU34's binary measured again first, equal
to its rows of the boot before): the synchronous JIT run 6,752.9 to
6,561.9 million instructions and 9,297.9 to 9,075.1 million estimated
cycles (-2.40%), the templates alone -2.40%, the interpreter 15,834.5 to
15,601.3 million (-1.47%), the image unchanged (7,025.9 and 7,026.1: it
runs no front end). The ratio of AU35 (ii), as AU36 (iii) records it on
compiler/bodies.ry (the Renyi compiler from images built by this
binary): checking 786.9 ms against AU34's Rust front end's 76.4 (10.3
times, the gate) and this binary's 48.9 (16.1 times); parsing 314.9
against 68.9 (4.6) and 62.2 (5.1; parse --json itself is unchanged,
282.4 million instructions on both binaries, the difference noise);
compiling 1,107.9 against 104.7 (10.6) and 89.1 (12.4). The stage stays
by AU1's rule.
AU38. The Rust parser's token comparisons by variant (stage A1 of
AU36). A token kind carries texts in three of its variants, so its
derived comparison is a function the compiler does not inline, and
peek called it at every look for a line break: TokenKind::eq was 18%
of renyi check compiler/bodies.ry on AU34's binary. The parser now
tests a kind with matches! wherever the kind compared is known (peek,
peek_second, skip_newlines, the line ends, the parameter test) and
through TokenKind::is where it is given (at, eat, expect): an
inlined comparison with the answer of == (a reserved word compares its
word, a kind that carries a text compares it all, any other kind its
variant alone); at_word, eat_word and Token::is_word match the word
in place; advance keeps its clone of the token for the callers that
use it, and the 74 that drop it call bump, which only moves the
cursor; expect and expect_word answer the span, all their callers
used, where they cloned the token; identifier and type_name, the most
frequent, read the kind and the span where they lie. The lexer's two
comparisons of a kind (the token pushed against raw, the dot before a
member) are matches! too. Measured on one boot against A0's binary
(AU37), callgrind and the best of nine alternating runs: renyi check
compiler/bodies.ry 242.9 to 186.8 million instructions (-23.1%), 47.0
to 40.5 ms (-13.8%); check compiler/checker.ry 371.3 to 286.7 million
(-22.8%), 66.8 to 60.0 ms (-10.1%); compile compiler/checker.ry 801.6
to 716.7 million (-10.6%), 129.7 to 126.4 ms (-2.5%); an empty program's
check 11.2 to 8.6 million (-23.7%: the library's declaration files are
parsed too), 6.9 to 6.5 ms; run examples/hello.ry 13.8 to 11.1
million (-19.4%), 6.7 to 6.4 ms; the thirty examples checked one at a
time 180.5 to 172.4 ms summed (-4.5%). AT1's rows: the synchronous JIT
run 6,561.9 to 6,478.6 million instructions and 9,075.1 to 8,890.5
million estimated cycles (-2.03%), the templates -0.96%, the interpreter
-0.56%, the image 7,026.1 to 7,044.5 (+0.26%, the same instructions: the
layout of the binary, which AU32 saw move a row by half a percent). Since
AU34's binary, check compiler/bodies.ry -57% in instructions. The
ratio as AU36 (iii) records it: checking 773.3 ms against AU34's Rust
front end's 69.9 (11.1 times, the gate) and this binary's 41.3 (18.7);
parsing 317.6 against 72.1 (4.4) and 59.5 (5.3); compiling 1,149.9
against 99.5 (11.6) and 84.2 (13.7). The stage stays by AU1's rule.
AU39. The module trees shared, not copied, by the declarations (the
first part of stage A4 of AU36). Three passes of the declarations
(World::resolve_types, resolve_abilities, resolve_functions) walk
a module's items while they fill the world's tables, and each copied
the module's whole item list first, bodies included, to free the world
for writing: the library's fifteen modules at every start and every
module of a project. A module's tree is now held by a count
(ModuleInfo::ast: Rc<ast::Module>), and each pass holds the tree by
another count while it walks it; every reader of the tree reads it as
before. Measured on one boot against A1's binary (AU38), callgrind and
the best of nine alternating runs: an empty program's check 8.56 to 6.73
million instructions (-21.3%), 6.2 to 5.7 ms; run examples/hello.ry
11.13 to 9.31 million (-16.4%), 6.5 to 5.9 ms; renyi check
compiler/bodies.ry 186.8 to 155.1 million (-16.9%), 46.8 to 38.4 ms
(-18.0%); check compiler/checker.ry 286.9 to 236.9 million (-17.4%),
63.4 to 52.3 ms (-17.5%); compile compiler/checker.ry 716.6 to 667.2
million (-6.9%), 132.3 to 116.5 ms (-11.9%); the thirty examples checked
one at a time 168.1 to 155.4 ms summed (-7.5%). AT1's rows: the
synchronous JIT run 6,478.6 to 6,429.4 million instructions and 8,890.5
to 8,770.9 million estimated cycles (-1.35%), the templates -1.31%, the
interpreter -0.49%, the image -0.34% (the same instructions). Since
AU34's binary, check compiler/bodies.ry 437.3 to 155.1 million
instructions (-64.5%). The ratio as AU36 (iii) records it: checking
775.2 ms against AU34's Rust front end's 72.3 (10.7 times, the gate) and
this binary's 35.0 (22.2); parsing 312.1 against 74.2 (4.2) and 58.5
(5.3); compiling 1,125.6 against 104.8 (10.7) and 81.0 (13.9). The stage
stays by AU1's rule. The second part of A4, the prelude and the modules
a program imports declared instead of the fifteen, was measured with a
binary built for the measure and not kept: an empty program's check a
further -38% in instructions (5.78 to 5.01 ms), run examples/hello.ry
-31% (6.51 to 5.55 ms), check compiler/bodies.ry -1.8%, and the
bytecode file of hello from 230.9 to 115.4 KB, since a program
carries the metadata of every function the world declares (200 of
hello's 201 are the library's). It changes every program's bytecode,
which the compiler in Renyi must write the same (the judges), and the
checker's fixes that name a library module not imported (write
\import std.environment`,write `import std.json exposing
JsonValue``) then need the names of every library module's types and
abilities without declaring them: its question goes to the owner.
**AU40. The owner's answers of 2026-10-10 after the first part of A4:
(i) the second part of A4 is done: a program declares the prelude, the
library modules it imports and the library modules those import, not
the fifteen; a fix that names a library module the program does not
import (write \import std.environment`,write `import std.json
exposing JsonValue`) reads the whole library then, on that error's
path only, with no index kept beside the declaration files; the Rust
front end and the compiler in Renyi change in one commit, and the
bytecode of every program changes with them; (ii) A2's cache keyed by
the sources servesrun,recordandtest: on a hit the image the
cache holds runs without the front end, the warnings the compile printed
are printed again, andrecord's code hash is kept in the entry; (iii)
an entry holds the content hash of every file the compile read and the
places where a manifest was looked for and not found, and a hit needs
all of them as they were; (iv) the cache is on by default under the
image cache's switch (--no-cache,RENYI_NO_CACHE,RENYI_CACHE_DIR).** The measures the questions gave: with a binary
built for the measure, the second part of A4 took a further 38% of an
empty program's check in instructions andrun examples/hello.ryfrom
6.51 to 5.55 ms, and halvedhello's bytecode file (AU39); the front
end the cache skips is about a tenth of the self-check's JIT run. The
alternatives the owner declined: for (i), keeping the fifteen modules,
or deciding after A2; for (ii), the cache forchecktoo, or forrun`
alone; for (iii), the sizes and the modification times first, the
hashes only when they changed; for (iv), off by default. (user)
AU41. The self-check frozen under bench/selfcheck/ (AU36 iv). The
program of AT1's measure, the compiler written in Renyi checking its own
bodies.ry, is now a copy of the thirteen files compiler/checker.ry
reaches, as they stood at decision AU39 (commit f1ba01b), under
bench/selfcheck/; tools/bench.py, tools/measure_size.sh and
tools/measure_native.sh run bench/selfcheck/checker.ry on
bench/selfcheck/bodies.ry, and CI checks the copy and holds it in
canonical layout with the other benchmark programs. compiler/ goes on
changing (the second part of A4 is the first change), the judges hold
it equal to the Rust front end, and the ratio of AU35 (ii) and AU36 (iii)
is taken on compiler/; the copy changes only when the language or the
library leaves it unable to check, and then as little as it needs. AU36
(iv) placed the copy before the compiler's sources change: the second
part of A4 changed them before the copy was made, and its first
measure, on compiler/ itself, showed the self-check's instructions
+0.2% to +0.4% and its estimate +0.5% to +1.5% from the two fields the
change adds to the Renyi world; the copy was taken from the commit
before that change, and the stage is measured on it.
AU42. A program declares the library modules it needs (the second
part of stage A4, AU40 i). The checker declares the prelude, std.json,
every library module a file of the program imports and the library
modules those import, transitively, in the library's order, instead of
the fifteen (Library::world_for, with Library::needed for the
closure); the resident world of AN1 declares the same, and the compiler
written in Renyi the same (project.ry's library_world and
needed_library). std.json is always among them: the runtime decodes
a recorded result and what a Python module returns through its decoder,
whatever the program imports, and builds its JsonError when a value
does not fit, which the conformance case of the Python bridge showed
when it was left out. A fix that names a library module the program does
not import reads the whole library on that error's path only: the
closest module to an unknown one among every module's name
(World::module_names), the import that would expose an unknown type or
ability (World::library_module_declaring, which parses the library
modules not declared), the import of a namespace used without it
(World::library_module_named); the world keeps the library and how many
of its modules it declared for them, and the compiler in Renyi keeps the
library's trees. Every program's bytecode changes with the modules
declared (examples/hello.ry's file from 230.9 to 124.8 KB), both
compilers alike: the gates passed, the judges among them. Measured on one
boot against AU39's binary, callgrind and the best of nine alternating
runs: an empty program's check 6.73 to 4.36 million instructions
(-35.3%), 5.5 to 4.7 ms (-14.2%); check examples/hello.ry -27.2%, 6.3 to
5.7 ms; run examples/hello.ry 9.31 to 6.69 million (-28.2%), 6.9 to 6.5
ms; check compiler/bodies.ry -1.6%, 35.8 to 34.5 ms; compile
compiler/checker.ry -0.8%, 121.6 to 117.9 ms; the thirty examples
checked one at a time 179.4 to 159.5 ms summed (-11.1%). AT1's rows on
the frozen self-check of AU41, both binaries on the same boot: the
instructions fall on every row (the synchronous JIT run 6,427.4 to 6,423.4
million, the image 4,994.1 to 4,989.3), the estimate rises on every row,
by 1.25% on the synchronous JIT run (8,768.1 to 8,877.5 million), 0.24%
on the templates, 0.11% on the interpreter and 0.21% on the image, the
whole of it simulated misses of the instruction cache and the branch
predictor (the synchronous row's I1 misses 105.2 to 115.0 million) from
the binary's layout, since the code the self-check runs did not change;
the times on the same boot, alternating runs, fall instead: the
self-check -3.5% at the best on one hardware thread and -1.9% on four,
records -5.6% and -6.2%, strings -6.9% and -7.3%, primes -4.5% and
-4.8%, json_round_trip -2.7% and -2.4%, each benchmark's front end
lighter. The stage stays: the letter of AU1's rule asks the estimate to
fall or a benchmark to gain 5% with the estimate losing at most 1%, and
the estimate lost 1.25% to the layout while two benchmarks gained more
than 5% and every time fell; the entry records the departure. The ratio
as AU36 (iii) records it: checking 777.9 ms against AU34's Rust front
end's 72.7 (10.7 times, the gate) and this binary's 35.9 (21.7); parsing
313.2 against 66.7 (4.7) and 56.1 (5.6); compiling 1,073.8 against 100.1
(10.7) and 75.7 (14.2).
AU43. The owner's answer of 2026-10-10 on what a hit of A2's cache
loads: every run compiled from its sources leaves the compiled program
in the cache, keyed by the sources, and a hit loads that program in
place of the front end; a program whose run compiled machine code
leaves its image as well (AU10, unchanged), which the hit then finds
by the program as before. The question followed from AU10's rule: an
image is left only by a run that compiled machine code, so a short
program such as examples/hello.ry has none, and a cache whose hits
load images alone (AU40 ii as it stood) would have spared it nothing,
where the front end is most of its time. The program is kept in the
binary encoding of AT3, about half its bytecode file. The alternatives
the owner declined: an image built in the background for every program
run, or hits for the programs with an image only. (user)
AU44. Stage A2 of the front end's round as built: the cache keyed by
the sources (AU40 ii to iv, AU43). Every run, record or test of
a program compiled from its sources, and the build --cache a run
leaves in the background, goes through one path, compile_cached in
crates/renyi/src/lib.rs: the entry, a .rys file in the cache's
directory beside the images, is named by a hash of the binary (its
version and its executable's path, size and modification time, so that a
build with the same version and another front end misses, with the names
and sizes of the library's declaration files, the extensions' among
them), the working directory and the path as given, since a compiled
program names its files as they are given; it holds a format line, one
line of JSON (every file the compile read with the content hash of its
text, or null for one looked for and not there, the manifests looked
for in the directories above the program and the .ry looked for before
a .renyi among them; the warnings the compile printed; the manifest's
code hash and dependencies when the run wanted a manifest, else null)
and then the program in the binary encoding of AT3. A hit is an entry
whose files all read as they did (renyi_package::unchanged: each read
again and hashed) and which holds a manifest when one is wanted: the
warnings are printed again, the program is decoded, no front end runs,
and the image cache's entry is named from the encoding held (AU10,
unchanged, which a run that compiled machine code still fills). A miss
compiles inside renyi_package::noting, every file read through
read_text noted (the main file's read too), computes the code hash and
the dependencies when a manifest is wanted, writes the entry to a
.part file and renames it, and goes on; a compile with errors stores
nothing. The entries of both caches count against the 256 MB together,
the least recently used going first; --no-cache and RENYI_NO_CACHE
turn both off; RENYI_CACHE_REPORT=1 prints a line on a hit and on a
store, for the tests. serve, reproduce, check, compile, build
to a file and the MCP server keep the front end. The first build hashed
the text of the library's declaration files for the key at every run:
1.7 million instructions on this machine, which has no SHA extensions,
more than the front end a hit of hello skips (the hit 6.33 million
instructions against 6.72 with the cache off); the executable's identity
covers the library compiled into it, so the key takes the modules' names
and sizes, and the hit fell to 4.53 million (-32.7% against the cache
off; a miss 7.91 million, +17.6%). Measured on one boot against the
binary before the stage (d27fd5a), callgrind for the instructions and
the best of seven alternating runs for the times: run
examples/hello.ry 7.4 ms with the cache off on the binary before and
7.6 on this one, 5.8 on a hit (-24%; 6.73 to 4.53 million instructions)
and 7.6 on a miss (7.92 million instructions, the medians of seven 8.5
against 9.7 ms), where the study had estimated about 5 ms for a hit; the
self-check (bench/selfcheck/checker.ry on its bodies.ry): the cold
JIT run 1,041 ms on the binary before and 1,006 on this one (the code it
runs is unchanged), the second run as a user sees it 822 ms before (the
front end, then the image from the image cache) and 762 now (both caches
hit, -7.3%), 823 and 731 on one hardware thread (-11.2%), the medians of
three 903 to 783 and 849 to 780; the cost of a miss, the files read
again and hashed (600 KB), the program encoded (761 KB) and the entry
written, 1,064 ms against the cold run's 1,006 for the self-check and
nothing measurable for hello (the instructions +17.7%); the image's
build in the background after the miss is as before. AT1's rows on the
self-check, cachegrind on both binaries: the rows that run with the
cache off are unmoved, the interpreter 11,613.9 to 11,613.4 million
instructions and its estimate +0.02%, the image 4,992.4 million on both
and its estimate -0.19%, the synchronous JIT run 6,460.0 to 6,460.5
million instructions (+0.01%) with its estimate 9,097.0 to 9,030.3
million (-0.73%, the layout: the simulated misses of the instruction
cache fell), the default JIT row within the compile thread's variation
(+1.0%); the cached run row, the second run of a program as a user
sees it, which now hits both caches, 5,440.7 to 5,071.2 million
instructions (-6.8%) and its estimate 7,782.6 to 7,251.4 million
(-6.8%): what it pays above the row that runs the image given on the
command line, the front end and the encoding hashed before, 448.2
million instructions, is now 78.8 million, the files read again and
hashed (sha256 in software here: about 55 instructions a byte over the
self-check's 600 KB), the encoding hashed for the image cache's name and
the program decoded. The ratio of AU36 (iii) is measured with the cache
off and does not move with this stage, the Rust front end being AU42's:
on this boot, nine alternating runs on a quiet machine, checking 795.9
ms against the Rust front end's 38.3 on this binary (20.8 times) and
38.7 on the binary before the stage (20.5), against AU34's 72.7 the 10.7
of AU42; parsing 316.5 against 61.3 (5.2) and 59.2 (5.3); compiling
1,039.2 against 81.2 (12.8) and 74.1 (14.0).
AU45. Stage B5 of the front end's round as built (AU36, stage 6): a
comparison of two Integers of which at least one is boxed, inline in
both tiers. Before a comparison on boxed operands calls rt_compare
(AU13), the generated code of both tiers now tests, when both operands
are Integers by the checker's type (is_integer in native/infer.rs,
beside is_text, from the type the bytecode notes for what an op
pushes, AU1 stage iv) or by the analysis (a small Integer in a register,
Abs::Int, as a literal bound is), that the boxed ones are small (the
value's tag and the Int's tag), compares the payloads with the op's
condition (is, is not, is less than, is at most, is greater
than, is at least), a register operand read from its register, and
takes the Boolean into its register on the Cranelift tier
(compare_small_integers in native/codegen.rs, after
compare_small_texts) or writes it over the left operand on the
template tier (template/mod.rs, where every value lies boxed in its
slot and the tags are tested alike); the boxed operands are dropped
without a release, since a small Integer holds no count; a big Integer
on either side, or a value the checker typed otherwise (Number, a
maybe), falls through to the helper as before. Code format 13. The
case it serves: an Integer read from a list, a field, a maybe or an
otherwise, which the abstract interpretation cannot hold in a
register, compared with another such or with a literal, as a lexer over
code points compares at every character; bench/micro/ scan_codes.ry is
that scan, a lexer's classification of forty codes read from a list
against literal bounds, measured per turn by tools/measure_native.sh.
Held to the interpreter by a test on each tier (every op, Integers from
a list, a field and a maybe, against each other and against literals,
two big Integers among the values), the judges and the conformance suite
on the template tier too. The first build took only two boxed operands
and left a boxed Integer beside a literal, the common shape, to the
helper: the scan's instructions per turn did not move; the build
measured here takes both shapes. Measured on one boot against AU44's
binary, cachegrind and callgrind for the instructions, the best of five
alternating runs for the times: scan_codes 33,793 instructions a turn
on the Cranelift tier and 33,384 on the template tier before, 17,525 and
16,877 now (-48% and -49%; the interpreter's 65,489 unchanged); AT1's
rows on the self-check: the synchronous JIT run 6,460.5 to 6,424.9
million instructions (-0.55%) and its estimate 9,030.3 to 8,961.2
million (-0.77%), the image 4,992.4 to 4,984.6 million (-0.16%; its
estimate +0.19%, the layout), the interpreter unchanged (11,613.4 to
11,613.1 million), the cached run row 5,071.2 to 5,063.3 million
(-0.16%); the self-check's rt_compare 152.2 to 123.3 million
instructions inclusive (2.36% to 1.92% of the synchronous run; what
remains compares texts not held in the value, records, variants and
Integers the checker did not type); the four benchmarks, synchronous,
primes 294.5 to 290.3 million instructions (-1.4%) and the other three
unchanged, none of them comparing a boxed Integer in its loop; in
wall-clock, scan_codes 54.7 to 24.0 ms on four hardware threads and
57.7 to 26.1 on one (-56% and -55%), the self-check 976.7 to 954.8 ms on
four (-2.2%) and 1,016.6 to 952.2 on one (-6.3%), primes 40 to 36 ms,
the other benchmarks within the run-to-run noise of their 5 ms. The
default JIT row and the benchmarks counted with the compile thread on
vary with its timing under cachegrind (records read 307 to 357 million
that way and 241.2 million on both binaries synchronously): the
synchronous counts are the ones to compare, as item 2 of the handoff's
"Start here" says. The ratio of AU36 (iii), with AU34's binary built
again from 44782aa on this boot: checking 755.9 ms against AU34's Rust
front end's 75.8 (10.0 times, the gate; 10.7 at AU42) and this binary's
38.2 (19.8); parsing 313.0 against 58.7 (5.3) and 63.3 (4.9); compiling
1,035.2 against 99.0 (10.5) and 80.4 (12.9); the Renyi checker's time
fell from 806 ms at AU44 to 756, the stage's gain on the program the
round is for.
AU46. Stage B1 of the front end's round as built (AU36, stage 6): the
Renyi lexer rewritten for speed with the library as it is.
compiler/lexer.ry keeps its tokens, its diagnostics (codes, messages,
fixes, spans and recovery, AD1) and its public functions, and the judges
hold it byte-equal to the Rust lexer as before; what changed is how it
runs. lex_range is one loop over the characters that skips a blank and
takes a line break itself and calls next_step for the rest, with the
previous token kept in a binding rather than read from the list at every
step; a step's product is a sum, Single(token) on the common path,
else Several(tokens, diagnostics, next), so that a token costs its own
record and one variant, not a record, a list and a copy; the scans are
loops of their own without the closure and the call per character that
scan_while and char_at made (scan_word, scan_name_tail,
scan_alphanumeric, scan_digits, scan_spaces, scan_operator_tail,
plain_run_end), each reading chars.at(position) otherwise "" in
place (AU34) and classifying by contains on the three short texts of
the character classes, the likeliest class tested first; the reserved
words, the phrases, the phrase starters and the symbols are Sets built
once from their lists (to_set, a constant evaluated on first use); a
word's text is sliced once and its token built from it; a comparison
with a variant (token.kind is Symbol(text: "."), which built the
variant) is a match on the kind, the position compared first; a plain
run of a text literal is copied by one slice, not a concatenation per
character. Three ways to classify a character were measured first, per
character on the JIT tier: a search in a short text 341 instructions, a
Set lookup 649, two ordering comparisons 305; the search stays, as
AU36 said, for its reading. compiler/lex_only.ry, a driver that lexes
a file as many times as asked and prints a count, measures the lexer
alone (the token dump's printing is 40% of tokens.ry). Measured on
AU45's binary, callgrind synchronous, per lex of compiler/bodies.ry in
the steady state (three runs against one): 982.9 to 514.5 million
instructions (-47.7%), in four cuts of 634.5 (the scans and the sets),
576.7 (the step as a sum, the previous token kept), 542.1 (the word's
token built once, the dot's position first) and 514.5 (the plain runs
sliced); renyi run compiler/tokens.ry compiler/bodies.ry 2,197.8 to
1,740.4 million instructions (-20.8%, the dump's printing unchanged in
it) and 388.1 to 335.3 ms; the lexer alone 112.4 to 64.8 ms a lex in the
steady state (-42%). The ratio of AU36 (iii), the Rust side unchanged,
seven alternating runs on a quiet machine: checking 649.2 ms against
AU34's Rust front end's 73.3 (8.9 times, the gate, from 10.0 at AU45)
and this binary's 36.5 (17.8); parsing 258.0 against 62.0 (4.2, from
5.3) and 58.1 (4.4); compiling 953.0 against 105.3 (9.1, from 10.5) and
78.6 (12.1); the Renyi checker on compiler/bodies.ry 756 to 649 ms,
since every front end's command runs the lexer first. The judges and the
conformance suite passed; the frozen self-check of AU41 does not move.
What remains in the lexer by the profiler: the scan of a word (28%, the
contains per character its floor with the library as it is: a method
answering code points is the lever B5 was the condition for, a library
addition for the owner to decide), the loop itself (21%), the word's
lookups (9%).
AU47. Stage B2 of the front end's round, the first cuts: the Renyi
parser's keyword and symbol tests and its token reads. is_word and
is_symbol in compiler/parser.ry, the funnels of every keyword and
symbol test, built a variant to compare the token's kind with
(token.kind is Word(spelling: spelling)); they match the kind and
compare the texts; token_at answers cursor.tokens.at(index) otherwise
end_token(cursor) in place of a match with a crash arm, and peek
reads the token under the cursor itself in place of two nested calls.
The judges hold the parser byte-equal as before. compiler/parse_only.ry
<file> [turns], the driver of the measure (the file lexed once, parsed
turns times), gives the parser alone as the difference between three
turns and one under callgrind: 1,197.1 to 1,113.7 million instructions
per parse of compiler/bodies.ry after the first cut and 1,039.2 after
the second (-13.2%); 118.7 ms a parse in the steady state after them;
the ratio of AU36 (iii), seven alternating runs, the Rust side
unchanged: checking 630.3 ms against AU34's Rust front end's 73.3 (8.6
times, the gate, from 8.9 after B1 and 10.0 at AU45) and this binary's
38.8 (16.3); parsing 263.7 against 62.1 (4.2) and 65.9 (4.0); compiling
909.8 against 97.8 (9.3) and 77.9 (11.7). What the profiler leaves, and
the rest of B2 as AU36 set it: peek 16% (a Peek record per look, 54
call sites), binary_chain 6%, token_at and after_breaks 9%
together, is_symbol and is_word 7%, the cursor copied by with
position: at 34 sites: the cursor that builds no Peek per look and
the keywords and symbols as variants without fields compared by tag
(AU36), which the handoff's plan for B2 lays out, are the stage's
remaining cuts.
AU48. B2, the rest: a look as an index with no record per look, and
the expression levels as one loop. compiler/parser.ry looked at the
next significant token through peek, which built a Peek record (the
token and the cursor after the look) per look at 54 sites, and every
consumer read both back; the expression parser went through eight levels
(or, and, not, a comparison, with, the additive, the
multiplicative and power), each a function that peeked once, tested
its own operators and built a Parsed record on the way back, so that
one operand cost eight looks and eight records, and a statement's end
eight evaluations of the line-break rule. Two cuts. (i)
peek_at(cursor) answers the index of the next significant token (the
position, or past the line breaks the layout rules skip), token_at
reads the token at it and moved(cursor, look) is the cursor there (the
cursor itself when the look did not move, else with position:), so a
look builds nothing; the sites that consume what they looked at advance
with cursor with position: look + 1, in place when the cursor is held
once; second_token takes the look's index; bump, past_word and
past_symbol are advance, expect_word and expect_symbol for the
callers that drop the token (13, 32 and 11 sites), and the three keep
their Peek for the callers that keep the token's span, expect_word
and expect_symbol reading it back as previous(after); expression's
otherwise, not, with and power test their word inline; peek
stays at the 11 sites of rare paths (a hole, the module header, an item,
a loop source, a match fallback). (ii) binary(cursor, lowest) parses
an expression of the operators from the level lowest up in one loop:
the head is a not with its operand (when lowest allows it) or a
postfix expression; then while the next token is a binary operator whose
level lies between lowest and a ceiling, it is consumed and its right
operand parsed from the next level (from the same for power, which
associates to the right); a comparison lowers the ceiling below itself
(one comparison per operand, as the levels had it), with takes its
update list and lowers the ceiling below itself, and a not head lowers
it below the comparison; binary_operator maps a token to its
BinaryOp in one match, level_of gives an operator's level;
or_expression and additive are the entries at their levels. The same
tree, byte for byte: the quick judge on the 117 programs of the corpus,
the conformance suite, compiler/, bench/, the starter pack and the
library's declarations, the four judges of
crates/renyi/tests/selfhost.rs, and 24 probes of the levels' edges (a
not before a comparison, with on either side of a comparison,
chained power, a second with or a second comparison refused,
operators without operands, a ( left open) through both parsers. The
parser alone (compiler/parse_only.ry, the difference between three
turns and one under callgrind with RENYI_NATIVE_SYNC=1, AU47's
measure; the compile thread's share varies from run to run under
valgrind, so the default mode does not measure): 1,039.2 to 998.6
million instructions per parse of compiler/bodies.ry after (i) (-3.9%:
a look's record was a smaller part of its cost than its calls) and 809.6
after (ii) (-18.9%; -22.1% in all, against the 800 the stage estimated);
96 ms a parse in the steady state (twenty turns less ten, by
wall-clock), from 118.7 at AU47. The ratio of AU36 (iii), seven
alternating runs, this binary AU45's (the VM unchanged): checking 578.6
ms (from 630.3) against AU34's Rust front end's 90.2 on this run (6.4
times; 7.9 against the 73.3 the reference took at AU47's run) and this
binary's 40.6 (14.3); parsing 231.7 (from 263.7) against 62.7 (3.7) and
60.7 (3.8); compiling 873.0 (from 909.8) against 122.1 (7.2) and 83.3
(10.5). What callgrind attributes on the three-turn run beside the
generated code: the frees of values 11%, rt_compare 6.6% inclusive
(the keyword and symbol tests among them, and the lexer's one-character
comparisons), leave_frame 5.5%, rt_construct 4.5%, the with copies
3.5%, rt_is_variant 2.2% (a helper call per match arm on a variant,
the subject cloned for it and dropped after), the reads of module
constants 0.5%. The keywords and symbols as variants without fields, the
cut AU36 named, would turn the keyword tests' text comparisons into tag
tests: bounded by rt_compare's share, it waits for the measure after
the VM's own cuts. The variant test in place in both tiers, which every
match of every program pays a helper call for, is the next cut.
AU49. A variant test in place on both tiers. Op::IsVariant(tag),
the test every match arm on a variant pattern runs (both emitters put
Load(slot), IsVariant(tag) and JumpIfFalse before an arm's body:
compile/pattern.rs and compiler/emit.ry), was a helper call on both
native tiers: rt_is_variant popped the value, unwrapped a guarded one,
compared the tag and wrote the answer for the generated code to read
back, so an arm cost the clone of the subject, the call and the drop
inside it; the parser's three-turn run spent 2.2% in the helper (AU48),
and the checker matches on the tree and the types everywhere. Both tiers
now test in place: the value's tag at its address; for TAG_VARIANT,
its block's tag at RECORD_TAG through the Rc at PAYLOAD (the
layout of AU27), compared with the op's; the value released where it
lies (AU29's sequence on the template tier, AU32's on the Cranelift
tier) and the answer a Boolean, in a register on the Cranelift tier and
boxed where the value lay on the template tier; a typed top (an Integer,
a Boolean or a Float in a register) answers false without a read; a
Guarded value (tag 19, TAG_GUARDED in value::layout, the wrapper
of decision P3 that plain() unwraps) takes the helper, the Cranelift
tier's cold block with the stack's length stored for the pop and the
template tier's out-of-line sequence (Cold::Guarded). Code format 14.
Tests: one per tier matches fieldless variants, variants with fields and
a guarded JSON document (read through a capability with only to and
parsed by json.parse, whose result carries the origins) in loops,
against the interpreter; the layout test pins TAG_VARIANT and
TAG_GUARDED; the conformance suite and the four judges pass on the
template tier too. Measured by AT1's rule: the self-check's synchronous
JIT run 6,424.9 to 6,370.0 million instructions (-0.9%), 8,961.2 to
8,918.3 million cycles by the estimate (-0.5%); the image's run 4,984.6
to 4,927.3 million instructions (-1.1%), 7,185.8 to 7,088.5 by the
estimate (-1.4%), the cached run the same (-1.1%, -1.3%); the
interpreter unchanged; the image 8,678,512 to 8,824,368 bytes (+1.7%,
166.7 to 169.9 bytes of body per op: the sequence is longer than a
call); the micro benchmarks of AR1 unchanged, none of them matching a
variant; the parser alone 809.6 to 798.0 million instructions per parse
of compiler/bodies.ry (-1.4%). The ratio of AU36 (iii): checking 546.0
ms (578.6 on AU48's run, a noisier one: the reference binary took 90.2
ms then and 72.7 now) against AU34's Rust front end's 72.7 (7.5 times,
the gate) and this binary's 36.4 (15.0); parsing 226.3 against 59.9
(3.8) and 62.2 (3.6); compiling 849.6 against 102.4 (8.3) and 77.0
(11.0). The measure's lesson, now in the scripts: the compile thread's
share varies from run to run under valgrind, so tools/measure_size.sh
prints a JIT run, sync row beside the JIT run, the row two binaries
compare on, and tools/measure_native.sh exports RENYI_NATIVE_SYNC=1
(the micro benchmarks of two binaries differed by up to 15% without it
and are equal with it). What stays: the clone of the subject before the
test and its release after; a test that borrows the slot (TestVariant {
slot, tag }, the answer alone pushed) would spare both at the price of
a new op through both emitters, the bytecode file, the binary encoding,
the interpreter and both tiers, held equal by Z3's judge; a candidate
for the measure after B3, not a stage of its own.
AU50. Small callees expanded into their callers on the Cranelift tier:
built, measured, off. B3, the last stage of AU36's list, in the shape
the owner chose on 2026-10-11 (four questions, every recommended answer
taken): (1) a rewrite of the bytecode the Cranelift tier sees, not of
the program, so that the analysis, the translation of every op, the
interpreter, the template tier, the bytecode file and Z3's judge stay as
they are; (2) a hand-back to the interpreter from inside an expanded
callee rebuilds the frames the interpreter would have had, the caller's
stopped after the call and one per expanded callee around the point; (3)
the callees admitted: at most 20 ops, no loop, no needs, not
recursive, a handler, a crash and nested calls allowed (a callee's own
small callees once more), a caller growing by at most half its size,
measured by AT1's rule; (4) the gate of AU35 (ii) reconsidered after the
stage. As built (native/inline.rs, commit fb0cc2d): before
codegen::compile sees a code object, expand scans its ops for a
Call to a declared function with code that fits (CodeKind::Function,
as many parameters as arguments, at most CALLEE_LIMIT ops, no
capability since its frame would narrow the grant, no backward jump,
none of IterInit, IterNext, ListPush, GroupInsert, GroupFold,
SortByKey, Deadline, CheckDeadline, MarkStack, UnwindStack,
Check and Fail, the last because rt_fail leaves the frame, which
would be the caller's; not the caller nor a callee the expansion lies
in; an analysis that settles with every reachable Return leaving
exactly its result and no handled region of the callee's own open) and
replaces it by a Jump into a region appended after the caller's own
ops: the stores of the arguments into the region's slots (fresh slots
past the caller's locals and every earlier region's), the callee's ops
with their slots, constants (appended to the caller's pool) and jump
targets moved, every Return a jump to the region's exit, which
releases the region's slots as leaving the callee's frame would
(LoadMove, Pop per slot) and jumps to the op after the call with the
result on top, a reachable ReturnNothing a jump to a tail that pushes
Nothing first; a caller's candidates are admitted smallest first while
the budget lasts (the ops a region takes: the arguments, the callee's
ops, two per local, one or three for the tails), then the calls inside
the new regions once more (NESTING_LIMIT 2). The caller's own ops keep
their pcs, so a loop header, the template tier's promotion and the deopt
points of the caller's ops are as before; the generated code's prologue
stores the expanded height, since the frame the caller pushed has the
code object's own locals and the first helper that pushes would
otherwise push into a region's slot; an entry at a loop header moves the
operands up past the regions' slots and writes Nothing into them
(make_room_for_expansion), and the frame leave releases the code
object's own locals alone, the regions' holding Nothing at a return
(commit 2cc361c: counted as holders, they took every caller with a
region over the inline limit of four releases and through rt_truncate,
whose drops cost the parser's steady state 1.5%). Around it: the JIT
keeps the regions per code object and a constant pool per expanded one
(Jit::pools, the caller's constants followed by every expanded
callee's, which NativeState::constants points at and Vm::constant_at
reads for the helpers); the image carries the regions (image format 8;
tools/image_census.py reads it); a crash inside a region is located at
the callee's line (inline::location, Jit::inlined_location, from
Vm::abandon); a hand-back at a pc past the caller's ops
(rebuild_inlined_frames in runtime.rs) takes the expanded frame
apart into the caller's frame (its locals, then its operands below the
call, its marks recomputed) stopped after the call, or at the call when
the point lies in a region's prologue (the arguments already stored go
back onto the operands and the interpreter makes the call), and a frame
per expanded callee around the point, with its slots, the operand depth
its own analysis gives at that op, the handled regions open at the point
under the frames that own them and the frames' floors; a direct call
site that gets the hand-back runs the callee's frame to its end under
the frames built above it (Jit::rebuilt_frames, read by
rt_direct_after); a hand-back at a caller's own op drops the regions'
slots first. RENYI_NATIVE_INLINE=1 turns the expansion on,
RENYI_NATIVE_INLINE_BUDGET sets the ops a caller may gain and
RENYI_NATIVE_INLINE_LIMIT the largest callee (for the measure of
another rule, and for small programs whose callers would expand nothing
under the half rule, which the tests set), RENYI_NATIVE_INLINE_DUMP
prints every expansion, why a call was not expanded, the regions' slot
kinds and every rebuilt frame, RENYI_NATIVE_IR=<name> a code object's
Cranelift IR. Tests (tests/inline.rs, against the interpreter): the
doors of an expanded callee (a return, a nothing, a failure caught by
the caller, one caught by the callee's own handler, a crash located at
the callee's line, nested one level, in loops) and the hand-backs (an
overflow inside the callee's body, nested one level, the loop's mark and
the caller's state rebuilt; a big Integer stored into an Integer
parameter before the body began, the call then made by the interpreter);
the whole suite, the conformance suite on both tiers and the four judges
pass with the expansion on. Two bugs the probes found, for the record:
the stack's length at entry (the first helper pushed into a region's
slot and a moved argument read back as a stale value), and the direct
call's entry frame after a hand-back that built frames (the innermost
frame's result was taken as the callee's). What the rule admits on the
compiler written in Renyi (the dump): the parser's three-turn run
expands 24 callees into 10 of its 34 compiled code objects, the
checker's run 12 into 8 of 47; the budget refuses 27 calls (token_at
seven times, is_symbol three, moved two), the size limit 32
(peek_at itself is 56 ops, bump 22, second_token 28, level_of
53), a loop 7, the recursion 2, a fail 1 (past_word, past_symbol);
peek_at, 56 ops with a budget of 28, takes end_token (15) and
refuses its four token_at sites (19 each). Measured by AT1's rule on
this binary, the expansion on against off, since the binary with it off
is AU49's to the fourth digit on the image and the cached rows (the
synchronous JIT run differs by the layout alone: 6,390.6 against 6,369.7
million instructions, +0.3%, and 9,040.6 against 8,918.3 by the
estimate, +1.4%, all of it simulated misses of the instruction cache, as
AU42 saw): the synchronous JIT run 6,390.6 to 6,430.5 million
instructions (+0.6%), 9,040.6 to 9,033.8 by the estimate (-0.1%); the
image's run 4,926.2 to 4,960.9 (+0.7%), 7,088.2 to 7,180.1 by the
estimate (+1.3%); the cached run 5,008.0 to 5,039.1 (+0.6%), 7,174.4 to
7,260.9 (+1.2%); the interpreter unchanged; the image 8,824,368 to
9,786,304 bytes (+10.9%, 169.9 to 190.0 bytes of body per op, 771 to
1,049 deopt points). The rules loosened for the question's sake (callees
up to 60 ops, a budget of 1,000 ops a caller): the synchronous JIT run
6,973.8 (+9.1%), 9,817.7 by the estimate (+8.6%); the image's run
5,228.2 (+6.1%), 7,852.3 (+10.8%, the misses of the instruction cache
110.6 to 144.1 million); the image 19,516,672 bytes (+121%, 395.7 bytes
per op). The parser alone (three turns less one of
compiler/parse_only.ry on compiler/bodies.ry under callgrind,
RENYI_NATIVE_SYNC=1): 799.6 million instructions per parse off (798.0
at AU49), 845.6 on (+5.8%; 853.6 before 2cc361c), 1,344.7 loosened
(+68%); the difference is the compile: the three-turn run's
codegen::compile 606 to 705 million inclusive, 50 of the 54 million a
parse, the same 34 code objects and 1,731 ops giving 15% more Cranelift
instructions (67,446 to 77,702 in 7,705 to 8,799 blocks) and 65% more
compile time (181 to 298 ms), the register allocation being superlinear
in a function's size. The steady state (every code object compiled at
its first call, RENYI_NATIVE_HOT=0, three turns less one): 572.6
million per parse off, 574.5 on (+0.3%; 583.2 before 2cc361c), 635.6
loosened (+11.0%). The micro benchmarks of AR1 (instructions a turn): a
typed Integer call 595 to 562 (-33), a call with a record argument 727
to 626 (-101), a field read and a record built unchanged: an expanded
call does save, but AU21's direct call was already lean, and what a
region adds (a retain at the caller's load and a release at the exit per
boxed argument where the typed call borrows, the stores and the tails)
takes most of it back, while the hot sites stay calls under the budget
and the bigger functions miss the instruction cache more. The ratio of
AU36 (iii), tools/ratio.py target/renyi-au50 target/renyi-au34:
checking 577.1 ms against the reference's 68.7 (8.4 times, the gate) and
this binary's 36.1 (16.0), parsing 215.9 against 60.8 (3.6) and 58.7
(3.7), compiling 882.4 against 106.3 (8.3) and 80.2 (11.0); the
expansion off checking 583.0 against 78.8 (7.4) and 38.5 (15.2), parsing
213.2 against 66.9 (3.2) and 64.5 (3.3), compiling 821.1 against 101.0
(8.1) and 79.4 (10.3), on a machine loaded by the site's build, where
the reference binary itself took 68.7, 78.8 and 75.4 ms in the three
tables, so the tables compare within themselves and the expansion's cost
is the Renyi checker's 577 against 583 on a reference 13% apart;
loosened checking 679.1 against 75.4 (9.0) and 37.4 (18.1), parsing
250.4 against 62.3 (4.0) and 59.0 (4.2), compiling 988.0 against 108.9
(9.1) and 78.1 (12.6). The rule of AU1 decides: the cold run does not
fall and no benchmark of the four gains, so the expansion is off unless
RENYI_NATIVE_INLINE=1; the mechanism, the tests and the hand-back stay
for the owner's evaluation, which AU36's answer (4) placed here. The
levers that remain, for that evaluation: the compile cost (a cheaper
allocation for a big function, or expansion only into small callers,
where the hot calls are not); the borrowing of a region's boxed
arguments (a parameter the callee only reads could be aliased without a
retain, sparing some 30 instructions a call); the admission of the hot
sites (a snapshot of the hotness in the compile request, the callee
called most first, or one region shared by a callee's sites with a
return dispatch); a smaller protocol for the call itself instead of its
removal; and the compiler's own code (peek_at's four token_at sites
as one, the keywords as fieldless variants deferred at AU48, the lexer's
contains per character and the checker's loops over every character
for the line starts as library primitives).
AU51. The owner's answers after B3, and the next stage. Asked at the
end of the session of 2026-10-11, with AU50's numbers (four questions,
every recommended answer taken): (1) the gate of AU35 (ii) stays at 3
times the Rust front end's time on compiler/bodies.ry, and the work
goes on finding levers, the binary keeping the Rust front end meanwhile;
(2) the next lever is the compiler's own code, where the profile is
known: peek_at's four token_at sites as one, the keywords and
symbols as variants without fields (AU48's deferred cut), the lexer's
contains per character and the checker's loops over every character
for the line starts and the layout check as library primitives or as
loops over lines; (3) the expansion of AU50 stays in the tree, off
unless RENYI_NATIVE_INLINE=1, with its tests and its hand-back, for a
later refinement or measure; (4) the site's fourth round is final as it
stands. The stage this opens, B4 in the handoff's naming (stage 28 of
the roadmap): the cuts in the order of their expected gain per effort,
each judged byte-equal by the four judges, measured by the drivers
(compiler/lex_only.ry, parse_only.ry, checker.ry under callgrind
with RENYI_NATIVE_SYNC=1) and by the ratio of AU36 (iii), and recorded
in its own entry: (i) the checker's line starts and layout check over
lines instead of characters (report.line_starts,
checker.check_layout: 4.8% and 6.5% of the checker's interpreter
samples); (ii) the parser's look computed once per move of the cursor
and read from it by every test, instead of peek_at per test (peek_at
7%, token_at 3.7%, after_breaks 2.2% of the parse's samples); (iii)
the keywords and symbols as variants without fields compared by tag, in
place since AU49 (rt_compare 6.6% of the three-turn parse); (iv) the
lexer's scan over a character class as a library primitive, a library
addition through the sketch, the declarations, the natives and the
checker's copy (scan_word 15%, lex_range 12%). The rule for each:
AU1's measure on the self-check does not apply (the frozen self-check is
bench/selfcheck/, which these cuts do not touch); a cut stays when its
driver's instructions fall and the judges pass.
AU52. B4's first cuts: the checker over lines, the parser's look in
the cursor, the lexer's scans as two list primitives. The stage AU51
opened, its cuts (i), (ii) and (iv), each judged byte-equal by the four
judges and the binary's tests. (i) report.line_starts takes the text
and measures the pieces of Text.split("\n") instead of walking every
character, and checker.check_layout walks the lines from those starts,
reading only each line's trailing run of spaces and tabs (tokens.ry
drops its own copy of the loop): the Renyi checker on
compiler/bodies.ry 4,898.3 to 4,802.1 million instructions (-2.0%; the
profiler's 11% was the interpreter's weight, the compiled loops being
cheaper). (ii) The parser's Cursor carries look, the index of the
next significant token past the line breaks the layout rules skip,
computed once wherever a cursor is built at a new position or nesting
(at_position, with_nesting, from look_from, the former peek_at;
the two constructors and the 47 sites that moved a cursor go through
them), and every test reads the field: the parser alone 799.4 to 792.9
million instructions per parse (-0.8%: the look was computed a few times
per position, not many). (iv) Two primitives on List of Item where
Item can Hash (a library addition, not a surface change:
docs/design/04-stdlib-sketch.md, library/std/prelude.ry and the
checker's copy, the natives with typed entries, the cheat sheet and its
two copies, three sentences of which were tightened to keep its budget,
2,999 of 3,000 tokens): run_of(members: Set of Item, start, stop), the
index after the longest run of members of the set from start below
stop, start itself when the item there is not in the set, and
run_until(stops, start, stop), the index of the first item of the set
from start below stop, or stop; the bounds are clamped to the list
as slice's are; a test in tests/semantics.rs. The lexer's seven
scans (scan_word, scan_name_tail, scan_alphanumeric,
scan_digits, scan_spaces, scan_operator_tail, line_end), loops
of one character per turn with one to three contains tests each, are
one call each over a character class kept as a set beside the texts it
comes from (word_set, name_tail_set, alphanumeric_set,
digit_set, digit_or_underscore_set, space_set,
operator_tail_set, line_break_set): the lexer alone
(compiler/lex_only.ry on bodies.ry, three turns less one) LEX_BEFORE
to LEX_AFTER million instructions per lex (-2.4%); the Renyi checker
on bodies.ry 4,750.9 million (-1.1% against (i)'s 4,802.1, -3.0% for
the three cuts). The ratio of AU36 (iii) after the three cuts: checking
590.5 ms against the reference's 78.5 (7.5 times, the gate) and this
binary's 38.7 (15.3), parsing 207.9 against 65.6 (3.2) and 62.2 (3.3),
compiling 888.9 against 102.1 (8.7) and 81.8 (10.9): the ratio stays at
7.5, the three cuts' 3% in instructions under the wall-clock's noise.
What stays for the stage: (iii), the keywords and symbols as variants
without fields (rt_compare 6.6% of the three-turn parse), and whatever
the profile shows next.
AU53. B4's cut (iii): the reserved words, phrases and symbols as
Integer codes. AU48 deferred the keywords as variants without fields,
bounded by rt_compare's share (6.6% of the three-turn parse: every
is_word(token, "function") and is_symbol(token, ",") compared two
texts through the helper, and binary_operator tested up to fourteen
literal patterns per call). The cut takes a cheaper shape than variants:
a new module compiler/words.ry holds the reserved words, the phrases
and the symbols (moved from the lexer, which imports them back), gives
each a code (word_codes, symbol_codes, built once from the lists;
the words from 1 in list order, the symbols from 1000) and a public
constant per spelling (word_function, word_is_at_least,
symbol_comma, 116 of them, each with its purpose line), with
word_code, symbol_code and spelling_of for the few sites that hold
a text. The lexer's Token carries code (a Word's spelling or a
Symbol's text looked up once at lex time, 0 for every other kind; at
first through make_token and code_of, then as the third step below
says); the parser's is_word, is_symbol, eat_*, past_* and
expect_* take a code and compare token.code is code, an Integer
compare in place since AU2, and binary_operator is a chain of such
compares on the token's code; 153 call sites were rewritten mechanically
(a scanner over each call's argument list, the literal to its constant;
a variable text goes through word_code or symbol_code), the match
arms with literal field patterns stay as they were (when Word(spelling:
"let"), some twenty, off the hot paths but the statement and item
dispatch). The token dump, the tree and every diagnostic are unchanged:
the tokens judge and the parse judge on 118 files, the four judges and
the binary's tests pass. Measured in three steps, each by its driver
under callgrind (RENYI_NATIVE_SYNC=1; the parser alone three turns
less one of compiler/parse_only.ry on bodies.ry, the lexer alone
likewise with lex_only.ry, the checker one run of checker.ry).
First, the cut alone: the parser 792.7 to 806.1 million instructions per
parse (+1.7%), because a read of a module constant is Op::Global,
which both tiers compiled as a call to rt_global (the VM's table of
built constants behind a status check), and the parser now reads one at
every test where it compared a literal before; the lexer 506.6 to 562.0
million per lex (+10.9%), because every token went through make_token
and code_of, three calls and a map lookup; the checker's run 4,750.9
to 4,903.0 million (+3.2%). Second, the VM's part, a module constant
read in place: the VM notes every constant it builds in a table the JIT
owns (Jit::note_global from Vm::global; GlobalSlot, the value with
one reference of its own behind a flag, reached through
NativeState::globals); both tiers copy the value from the table in
place once the flag is set and retain it there, and call rt_global
only until then (the template's Op::Global, and the Cranelift tier's
with the helper on a cold block); a compilation on the Cranelift tier
also takes a snapshot of the constants built to a small Integer
(small_globals, handed to the compile thread with its request) and
reads such a constant as the literal, an Int operand in a register
(infer::analyse takes the slice; codegen); code format 15; a test
per tier, module_constants_are_copied_in_place_once_built. Third, the
lexer's part: the one lookup that gives the code stands where the set
test stood (words.word_codes.get(text) otherwise 0 in lex_word,
symbol_codes.get(ch) in next_step; a phrase looks its own code up
once more), the hot tokens are built in place with code: 0, and
make_token serves the cold sites and the parser's end-of-file token.
After the three: the lexer alone 494.4 million per lex (-2.4% against
506.6), the parser alone 764.6 million per parse (-3.5% against 792.7),
the checker's run 4,691.7 million (-1.2% against 4,750.9; the cold phase
keeps part of the parser's gain, the compile and the first parse on
templates); AT1's measure of the VM's part on the self-check
(tools/measure_size.sh, the synchronous row, the binary before the
VM's part against this one): 6,389.0 to 6,376.4 million instructions
(-0.2%) and 9,002.1 to 8,955.4 million by the estimate (-0.5%); the
image row 4,930.2 to 4,918.3 million (-0.2%) and 7,084.1 to 7,039.8
million by the estimate (-0.6%), the image 14 KB larger (8,838,240
bytes) for the sequence per read. The ratio of AU36 (iii) after the four
cuts (tools/ratio.py): checking 589.8 and 606.6 ms on two runs of this
boot against the reference's 82.5 and 74.9 (7.2 and 8.1 times, the gate;
7.5 after the three cuts with the reference at 78.5) and this binary's
37.6 and 36.4 (15.7 and 16.7), parsing 221.4 and 229.4 against 61.9 and
67.4 (3.6 and 3.4), compiling 899.3 and 825.9 against 122.9 and 111.3
(7.3 and 7.4): unchanged within the wall-clock's noise, which is wider
than the cut's 1.2% in instructions. Also in this commit: AU52's natives
table gave index_of's typed entry to run_until and none to
index_of, which tests/extension.rs refused (CI red on e91cec0);
fixed.
AU54. B4's fifth cut: two lookups by index, the lexer's last append in
place, and a shared list appended with one copy. The profile of the
checker's run after AU53 (callgrind's callers and a census build that
named the Renyi site of every append that found its list shared):
Rc::make_mut in list_append cloned 4.9 million list items per run,
60,108 appends on shared lists, 84% of the items in bodies.record (the
body's references, a copy of the whole list per reference, since the
checker record arrives shared), then infer, declare_function and the
lexer's end-of-file append (24 copies of a file's tokens); and every
clone was at the list's exact length, so the push that followed moved it
again through realloc (memcpy 4.5% of the run, 143 million of it
under realloc). Beside it, find_binding built a reversed copy of the
scopes for each of its 62,285 lookups, and the emitter's lookup did
the same twice per name. The cut: (i) bodies.find_binding and
emit.lookup walk their scopes by index from the innermost, as
update_binding did; (ii) lexer.lex appends the end-of-file token
with change lexed to lexed with tokens: lexed.tokens.append(eof),
AU11's form, so the field is taken and the list appended in place; (iii)
the natives append and append_all copy a shared list once, with room
for what is appended (Rc::get_mut for the list held once, else
Vec::with_capacity and one extend), where make_mut cloned it at
its length and the push moved it again. Judged byte-equal by the quick
judges on 118 files and the four judges. The measure (callgrind,
RENYI_NATIVE_SYNC=1): the VM's part alone, on the committed sources,
the checker's run 4,691.7 to 4,558.4 million instructions (-2.8%); with
the two Renyi parts, 4,544.4 million (-3.1%); the lexer alone 494.4 to
491.4 million per lex (-0.6%); AT1's measure of the VM's part on the
self-check (the synchronous row, AU53's binary against this one):
6,376.4 to 6,235.9 million instructions (-2.2%) and 8,955.4 to 8,746.6
million by the estimate (-2.3%); the image row 4,918.3 to 4,775.6
million (-2.9%) and 7,039.8 to 6,851.8 million by the estimate (-2.7%),
the interpreter -1.2%, the image unchanged in size. What the profile
leaves: the copies that remain are the checker's own shape, a function
that takes checker: Checker and updates a mutable copy of it while the
parameter slot still holds the record, so every with copies the record
and every taken field is cloned (AU11 counted 47,000 of its 71,000
updates in the slot finding the record shared); the liveness rule AU11
left to the next profile (a let or a return that reads a local for
the last time moves it) is the next cut.
AU55. B4's sixth cut: the last read of a local moves it (the liveness
rule AU11 deferred), a taken field read in place on both tiers, and the
checker's values read before its checkers. AU54 left the copies that
remain to the checker's own shape: a function takes checker: Checker
and derives a mutable copy while the parameter slot still holds the
record, so the record is shared wherever it is updated. The rule, in
both emitters (crates/renyi_vm/src/compile/liveness.rs, the same in
compiler/emit.ry, held equal by the compile judge): a read of a local
is its last when it is the only read of that local at its statement's
own level, the local is read nowhere in the statement's nested blocks
nor after the statement in its block or in the blocks around it, and
every loop around the statement binds the local anew on each turn (a
read inside a query, or inside a loop's filter, key or condition, runs
more than once and is never last); a write is no mention, since a read
after it sees what it stored; a nested block whose last statement is
return, fail or crash never falls through, so its reads need no
later-statement and no loop check. Such a read is a LoadMove, and
x.f on such a local a TakeField (AU11's op), so a record or a
collection held once stays held once into the call, the construct or the
update that follows. The analysis walks each block from its last
statement, the names mentioned after it kept as a set, a frame per
enclosing block (the names mentioned after its statement, and the names
a loop binds), two traversals per node. TakeField went through
rt_take_field on both tiers while LoadField read in place through
the site's cache (AU21), and the rule turns 816 field reads of the
checker into takes, so the first measure came out worse (the checker's
run 4,544.4 to 4,659.6 million); both tiers now take a field in place as
they read one: a record of the cached type held once gives up the field,
Nothing left in its place, a shared one gives a copy with one more
reference, a variant or a miss goes through the helper. The checker's
code (compiler/bodies.ry) read against the rule in two ways, both
rewritten by a script and judged byte-equal by the checker judge: 27
reads of the parameter checker after the derived value existed (a
stale read, where the Rust checker's &mut self reads the latest state)
now read the derived value; and 113 Done results read their .value
after their .checker, keeping the record alive at the take, so each
binds its value first (let done_value be done.value) and the two done
with checker: updates construct a fresh Done, which makes the
.checker read the last read of done. In the checker's bytecode 4,914
loads become moves and 816 field reads takes. The measure (callgrind,
RENYI_NATIVE_SYNC=1, against AU54): the checker's run 4,544.4 to
4,470.1 million (-1.6%), the parser alone 764.6 to 767.9 million per
parse (+0.4%), the lexer alone 491.4 to 498.1 million per lex (+1.4%:
its code is bound by the hash of each character against a set, and a
take in place tests the count where a read did not); the Rust front
end's compile of the checker 723.9 to 758.2 million for the analysis
(+4.7%, the hashing of the names in its sets; interning them to bits is
the fix left); AT1's measure of the tiers' part on the self-check
6,235.9 to 6,260.7 million instructions (+0.4%) and 8,746.6 to 8,792.5
million by the estimate (+0.5%); the image row 4,775.6 to 4,775.0
million in instructions and 6,851.8 to 6,884.4 million by the estimate
(+0.5%), the code 1.4% larger (the frozen compiler of AU39 keeps the
shape the rule does not reach, and pays the take's count test and the
larger code); the ratio of AU36 (iii) checking 557.9 ms against the
reference's 81.4 (6.9 times, the gate; 7.2 and 8.1 after AU53, with the
Renyi checker at 589.8 and 606.6) and this binary's 38.4 (14.5), parsing
215.6 against 75.3 (2.9) and 64.0 (3.4), compiling 922.5 against 143.3
(6.4) and 90.6 (10.2), the best of five runs: the checker's time is the
first of the stage's cuts to move outside the wall-clock's noise, and
the compile row pays the analysis written in Renyi. CLAUDE.md's rows for
compile/, the tiers and compiler/ say what is there now.
AU56. B4's seventh cut: the frame leave drops only the slots that hold
a counted block. After AU55 the largest VM cost of the checker's run
was the return: rt_return 399 million instructions inclusive (8.9%),
of which leave_frame's truncation of the frame's slots called the drop
glue of Value on every slot, 10.6 million times per run, most of them
on plain values (Nothing, a Boolean, a small Integer, a Float, a text
held in the value) with nothing to drop.
Pinned<Value>::truncate_values reads each slot's tag and drops only a
value whose tag is in COUNTED_OR_INTEGER (the mask the generated code
tests before a retain or a release, decisions AU29 and AU32); the frame
leave of the generated code (runtime::leave_frame), the interpreter's
leave! and rt_truncate use it. The measure (callgrind,
RENYI_NATIVE_SYNC=1, against AU55): the checker's run 4,470.1 to
4,432.9 million (-0.8%), the parser alone 767.9 to 763.4 million per
parse (-0.6%), the lexer alone 498.1 to 493.7 million per lex (-0.9%);
AT1's measure on the self-check the synchronous row 6,260.7 to 6,223.8
million instructions (-0.6%) and 8,792.5 to 8,771.4 million by the
estimate (-0.2%), the image row 4,775.0 to 4,726.6 million (-1.0%) and
6,884.4 to 6,811.1 million by the estimate (-1.1%), the interpreter
unchanged. Also in the stage's record: the cheat sheet stood at 3,001
tokens by the gate's tokenizer after AU52 (the byte estimate this
environment can take said 2,999), which kept CI red from d172887 to
fa27d73; two phrases a word shorter (81c5ef9).
AU57. B4's eighth cut: List.with_at, a replacement by index in
place; the hash of a small text by its two words, measured slower and
left out. lists.replace_at(items, index, item), by which the
compiler written in Renyi updates a list by position (twenty call
sites: the checker's variables and scopes in bodies.ry, the world's
modules, types, functions, abilities and parameters in declare.ry,
the emitter's ops, codes, types and fields in emit.ry), built three
lists per call: take(index), append(item) and append_all of
drop(index + 1). The prelude gains with_at(self: List of Item,
index: Integer, item: Item) returns List of Item for any Item, a
library addition (the sketch, library/std/prelude.ry and the
checker's copy, the native list_with_at in natives/prelude.rs, the
cheat sheet and its two copies, a test in
crates/renyi_vm/tests/semantics.rs): the list with the item at the
index replaced, in place when nothing else holds the list and with one
copy otherwise, the list as it was when the index is out of range,
which is what replace_at answered; replace_at is now that one call.
The cut's other half hashed a text held in the value (SmallText, at
most 15 bytes, which Value::text always uses for a text that short)
as its two words in place of its bytes, to spare the loop over them;
but the VM's maps and sets hash with the standard library's SipHash,
for which sixteen bytes cost more than the one to three bytes of a
typical token and the terminator (Hasher::write 26.1 to 50.3 million
instructions per lex), and with both halves the lexer alone went from
493.7 to 517.5 million instructions per lex (+4.8%), the parser alone
763.4 to 764.7 million per parse (+0.2%) and the checker's run 4,432.9
to 4,438.4 million (+0.1%), so the hash stays as it was. What the
profile names instead is a hasher of the VM's own for its maps and sets
(a multiplicative hash over the words, keyed per run, since SipHash's
keys are what defends a map against keys chosen to collide), a decision
of its own. The measure of with_at alone (callgrind,
RENYI_NATIVE_SYNC=1, against AU56): the checker's run 4,432.9 to
4,391.6 million (-0.9%), the parser alone 763.4 to 763.3 million per
parse and the lexer alone 493.7 to 493.6 million per lex (both
unchanged: neither calls it); the four judges byte-equal. The stage's
total: the checker's run 4,898.3 to 4,391.6 million (-10.3%). The cheat
sheet: the gate's two tokenizers, which the container's proxy keeps
tiktoken from fetching, are in the tiktoken-rs crate on crates.io
(the handoff says how to count with them offline); with with_at
listed and two phrases a word shorter it stands at 2,997 tokens by
o200k_base and 2,992 by cl100k_base, where the byte estimate says
2,992.
AU58. The owner's answers after B4: a new backend for the VM, its
design study first. Asked at the end of the session of 2026-10-11
(four questions, every recommended answer taken), with AU56's numbers
and AU57 under measure. The question set out the distance to the gate
of AU35 (ii) and what could cover it: cuts of one to three percent
each will not (B4's eight came to 10.3% of the checker's run), and a
new backend could (values unboxed, counts elided where ownership is
static, arguments in registers, records laid out as structures, and
the checker's data structures rewritten to suit them), months of work
by the question's estimate. The answers: (1) the new backend, its
design study first: the instructions of the checker's run attributed
by category, the backend's design, its stages with an estimate each,
then the stages one by one in the sessions after; the gate stays at 3
times, the road to it acknowledged as months long; (2) AU57's two cuts
recorded and pushed as usual (its second half was measured slower and
is left out, as AU57 records); (3) the measure stays the checker's run
on compiler/bodies.ry under callgrind and the ratio of AU36 (iii),
with a table by category beside them in each entry (the generated
code, the counts and the frames, the helpers, the allocation, the
hashing); (4) the first stage, which the study is to examine again:
the calling convention, scalar arguments and results in registers and
a parameter that is only read passed without a count, on both tiers,
with a flag per parameter in the bytecode (the return's helper was
8.9% of the checker's run before AU56, its largest single item). A
correction to the question's figures, made the same day: it put the
distance at seven times in instructions, comparing the Renyi checker
with this binary's own Rust front end (about 3,230 million by the
profile's shares against 153 million, 21 times), but the gate's
measure by AU36 (iii) is AU34's binary. Measured (callgrind, the image
cache off): the Renyi checker run from its image, as tools/ratio.py
runs it, 3,080.0 million instructions on today's compiler/bodies.ry;
AU34's renyi check of the same file 442.8 million (7.0 times, beside
the wall-clock's 6.9); this binary's renyi check 179.4 million (17.2
times). The gate asks the checker's image run to fall to 1,328.3
million, 2.3 times fewer instructions, as the wall-clock says (the
Renyi checker 557.9 ms against three times the reference's 81.4, 244);
the study takes the gate's measure. The session ended at the owner's
word, to save the progress and prepare the handoff, before the study
began.
AV. The icon and the wordmark (session 13)#
AV1. The mark is a war hammer on the accent tile; the wordmark is the
name signed in Ms Madi. The owner asked on 2026-10-11 for an icon that
does not read as the R language's, as the R on the accent tile did, and
chose over five rounds of rendered options (AskUserQuestion, each sheet
with the candidates in both themes, at 16 to 128 pixels, in the site's
header and in a browser tab): (1) the character 人 three ways and a dot
in brackets, which the owner set aside ("nothing to do with Chinese
characters; diverge"); (2) six directions (a kite, brackets as a kite, a
dot between angle brackets, a spark in brackets, glasses, a signature)
with eight dropped and why (an aperture read as a camera, a seal as a
gear, a grid of grants as an app launcher, a colon as a list, a tethered
dot as a pin, a spark on a line as a wand, a glass box as a package, a
kite-shaped icon too small in a square slot), after which the owner asked
for the name as a signature; (3) the name in forty-five script fonts, the
eight most like a signature shown with four marks to go beside it (a nib,
the signature's initial, a cross on a line, a wax seal): the owner took
Ms Madi, and the signature in the site's header, and asked for an R or Ry
made of a nib or other objects; (4) six such marks (a nib as the R's leg,
an R signed in one stroke with the nib at its end, Ry in the wordmark's
hand, an R cut out of a nib, a lens as the bowl, a ribbon's swallowtail
as the leg), after which the owner asked for Ry on a finer grid, or an
object such as an axe or a war hammer; (5) Ry on three grids (lit cells
of nine, a finer grid of sixteen, graph paper) and five objects (a gavel,
recommended for its meaning, the war hammer, an axe, a stamp, an anvil):
the owner took the war hammer. The colours were the owner's to leave
open, so they are the site's: the accent tile with the hammer in the
colour on the accent, in both themes. What is built: tools/brand.py
holds the mark (a square hammer with a flared face, a curved beak and a
top spike on a long haft, drawn upright on a grid of 24 and turned 40
degrees; the full drawing, with a grip band and a pommel, from 48 pixels
up, the plain one, a thicker haft, below) and the wordmark (the name in
Ms Madi, Robert Leuschke's script under the SIL Open Font License 1.1,
shaped by HarfBuzz and kept as one path, so that no page loads a font),
and writes the files made from them: docs/assets/renyi-mark.svg, the
README's logo in a light and a dark version (renyi-logo-light.svg,
renyi-logo-dark.svg, chosen by a picture element), the VS Code
extension's icon (editors/vscode/images/icon.png, 128 pixels) and the
icon of a .ry file in light and dark themes (file-light.svg,
file-dark.svg, the plain drawing), and the repository's social preview
(docs/assets/social-preview.png, 1,280 by 640: the mark, the
signature, the README's first sentence in Inter, the site's address),
the PNG files as screenshots by a headless Chromium. tools/site.py
takes the mark, the tab's icon and the wordmark from it and checks that
its colours are the site's; the header shows the mark and the signature,
the name kept for screen readers. The social preview reaches GitHub
through the repository's settings (Settings, General, Social preview),
an upload only the owner can make. The site's design stays as AU51 (4)
left it but for the header's brand. (user)
AW. The new backend (session 14)#
AW1. The design study of the new backend (AU58) and the owner's
answers: the Cranelift tier evolved in stages, the gate on the check
row, stage 0 first, the read-only flag in the bytecode, Done by a
convention per function, the natives' in-place entry through AK1's
API, the character tables with a hasher of the VM's own, the iterator
in two slots. The study is the handoff's section "Stage 29, the new
backend: the design study (session 14)", measured on 2026-10-11 on the
release build of 7cbbbe0 for Linux under WSL against AU34's binary
built from 44782aa the same way, by AU58's measure (callgrind on the
Renyi checker run from its image on compiler/bodies.ry, the image
built under valgrind --tool=none, the caches off). The attribution:
3,085.3 million instructions, of which the generated code 1,011.8
(32.8%), the counts and drops 448.2 (14.5%), the natives with their
calling helpers 358.8 (11.6%), mimalloc 258.9 (8.4%), the hashing and
equality 219.8 (7.1%), the records 208.1 (6.7%), the helpers' glue
(status, into_plain) 130.9 (4.2%), the comparisons 124.0 (4.0%),
the texts and copies 121.1 (3.9%), the calls through the VM's path
114.1 (3.7%), the load 46.2 (1.5%), the iterators 40.6 (1.3%); the
parse row 1,256.9 and the compile row 4,844.9 with the same shape; the
reference's check 441.6, parse --json 284.7, compile 365.6, so
the ratios by instructions are 6.99, 4.41 and 13.25 against the gate's
3. The findings: a call of a declared function costs about 130
instructions besides its body (2,770,541 calls, about 400 million); a
third of the frames leave through rt_truncate at 329 each (917,264
leaves, 301.8 million inclusive), which drops by the tags at run time
where the analysis knows most slots are moved out; 306,392 calls enter
generated code through the VM's path at about 435 each because an
Integer parameter's operand is boxed at the site, half of them a
module constant an image cannot know as a literal; a record update
costs about 1,070 (201,205 updates, 219.0 million) and a record's free
232 (1,084,633 frees, 251.2 million) while a construct costs 63; every
allocation goes through mimalloc's aligned entry and 641,578 through
its generic path; the natives' calling glue is about 150 million and
the lexer's character classes 409,270 of the run's 555,512 hashed
lookups; 521,364 comparisons go through the helper, 387,234 of them of
two values of a field-less variant type; a for each allocates an
iterator (238,534, about 95 million); the generated code's own
sequences are about 600 million for 55 million ops, the retains and
releases the larger half. The design weighed two roads: (A) the
Cranelift tier evolved in stages, each measured, the judges and the
conformance suite green at every step; (B) a new code generator with
the operand stack and the locals in registers, the frame record lazy,
the counts elided by dataflow, about 10% more than (A)'s stages for
three times the work and months without a measure. The stages of (A)
with their estimates: stage 0, the allocator entered by mimalloc's
plain functions for an alignment of at most 16 and a module constant
whose code object is a literal known to the JIT without the snapshot
(165 million, 5%); stage 1, the calling convention, a typed
parameter's boxed operand unboxed at the site, the leave by the static
ownership state of the slots, a parameter only read passed borrowed
under a flag per parameter in the bytecode (the callee's leave skips
it when entered directly, every other entry owns it, rt_deopt
retains it), the frame record cheaper (400 million, 13%); stage 2, the
records: with by static index with the copy in place, the two-field
result record returned in the caller's slots when the caller takes it
apart at once (Done), the frees in place (400 million, 13%); stage 3,
the natives answering in place through a second entry per native, the
character classes as 128-bit tables in run_of and run_until, the
hasher of the VM's own, status and into_plain off the path (315
million, 10%); stage 4, two values of a field-less variant type
compared in place, match by a table, the iterator in two slots (185
million, 6%); stage 5, the moves of AU17 written in the image and the
code objects decoded on demand (50 million); stage 6, AU50's expansion
measured again under the new convention (25 million); the checker's
own shape beside them (the lexer's text of a run, the lists shared
when appended, the linear searches, the parser's look): about 250
million. The sum, about 1,540 million, puts the check row near 1,550
million, 3.5 times the reference, the gate's 3.0 reached with the
checker's own cuts or (B)'s register-resident values after the stages.
The owner's answers, every recommended option (AskUserQuestion, two
batches of four): (1) road (A), the stages, over (B) and over "stages
0 to 2 then the choice"; (2) the gate of AU35 (ii) measured on the
check row alone, AU58's measure, the compile row (13.25 by
instructions, the emitter's shape) left to the emitter's own round
after it, over all three rows and over the check and parse rows; (3)
stage 0 first, over stage 1 as AU58 (4) named it and over stage 2; (4)
the read-only flag in the bytecode, a Boolean per parameter computed
by both emitters from the finished ops and held equal by the compile
judge, over the VM deriving it at load and over the leave by state
alone; (5) Done without its allocation by the convention per
function, over the checker rewritten and over leaving it; (6) a second
entry per native answering in place through AK1's registration API,
the standard library's hot natives first, over lean helpers for the
hot ones only (AU34's way) and over none; (7) the character classes as
tables and the hasher of the VM's own, over the tables alone and over
none; (8) the iterator in two slots as a bytecode change in both
emitters with the judges, over a lighter native in the slot and over
none. The order: stage 0, stage 1 as 1a, 1c, 1b, 1d, the character
tables and the hasher, stage 2 as 2a, 2b, 2c, the natives' entry and
the glue, stage 4, the checker's own cuts between the stages, stages 5
and 6 last; each measured by AU58's measure with the table by
category from the study's scripts, AT1's rows where the tiers change,
the benchmarks, the four judges and the conformance suite on both
tiers, kept by AT1's rule, its entry recording the table. (user)
AW2. Stage 0 of the new backend: the allocator entered by mimalloc's
plain functions, and the module constants an image builds before any
run. The first stage of AW1's order, on 2026-10-11, measured as AW1
prescribes. (i) The allocator: renyi::Allocator wrapped the
mimalloc crate's MiMalloc, which calls mi_malloc_aligned,
mi_zalloc_aligned and mi_realloc_aligned for every allocation;
mimalloc's aligned fast path serves only when the page's free list has
a block, and its generic path over-allocates every block whose size is
not a power of two (mi_malloc_aligned_at_generic, 621,420 of the
checker's 2,381,541 allocations in the study). The binary depends on
libmimalloc-sys itself now, and Plain calls mi_malloc,
mi_zalloc and mi_realloc for an alignment of at most 8 (every
block mimalloc hands out is a multiple of eight bytes at a multiple of
eight from a page area that starts sixteen-aligned, so the plain
entries honour it), the aligned entries above it; the VM's blocks
(Composite, Layout::from_size_align(size, align_of::<Value>())),
its vectors and its texts ask for eight or less, hashbrown's tables for
sixteen. (ii) The constants: the study's item was a module constant
whose code object is a Const and a Return, known to the JIT
without the snapshot; but the checker's constants are computed, not
literal (of its 184, 30 are a literal and 118 a native call on a
literal, symbol_code(",") and word_code("ability"), the rest lists,
sets and maps built from literals and from one another), so that rule
alone reached none of the parser's is_symbol(code: words.symbol_comma)
sites. Two parts then: Jit::new fills the table of module constants
(GlobalSlot, decision AU53) with every literal one, so that a run and
a build know them before the VM builds them; and image::build
evaluates on the interpreter every constant pure_constants admits and
notes the values with the JIT, so that a small Integer among them is a
literal in the image's code (Jit::small_globals) and the call sites
that pass it reach the direct path. The values go with the build's VM;
the run builds its own on the first read as before (reference section
6), the same values by the purity. A constant's code is effect-free
(the checker admits no needs in one, capability-missing; a foreign
or a Python function needs foreign or python), so what it builds is
the same at every run unless a deadline passed while it was built (run
concurrently within needs nothing): pure_constants takes a constant
whose code reaches, through the declared functions it calls and the
constants it reads, no deadline, no ability call (a method on a type
parameter; one on a known type is a declared function), no call of a
function value and only natives without needs, as a fixed point over
the code objects; what an op or a native reaches through an ability's
implementation on a record (hash, equals, to_text) it does not
follow, such an implementation with a deadline in it having been a race
between two runs already. A constant whose build fails is left to the
run, which crashes at its first read as before, and a new VM builds the
rest; a constant whose build does not end would hang the build, as it
hangs the run that reads it. Neither part touches a format. The test:
crates/renyi_vm/tests/native.rs, a program with a literal constant,
one computed through a declared function, a list, one that fails, one
through an ability on a type parameter and one through a function
value, the pure five named, the run from the image equal to the
interpreter's. The measure (callgrind under WSL on the release build
for Linux, the images built under valgrind --tool=none, against the
binary of 7cbbbe0 measured the same way in AW1, the reference AU34's
44782aa): the check row 3,085.3 to 2,889.9 million instructions (-6.3%;
the study estimated 165 million, 5%), the parse row 1,256.9 to 1,162.8
(-7.5%), the compile row 4,844.9 to 4,608.8 (-4.9%); the ratios by
instructions against the reference's rows (441.6, 284.7 and 365.6) 6.54,
4.08 and 12.61 against the gate's 3 (6.99, 4.41 and 13.25 before); the
Rust front end's own rows on this binary, which the allocator serves
too, check 178.8 to 173.4 (-3.0%), parse --json 266.8 to 246.7
(-7.5%), compile 471.1 to 445.1 (-5.5%). The check row by category,
AW1's table against this one, in millions: the generated code 1,011.8
to 996.9, mimalloc 258.9 to 146.8 (the allocator's part, 112.1 against
the 100 estimated), the counts and drops 448.2 to 444.5, the calls
through the VM's path 114.1 to 57.3 (call_from_stack 306,330 to
141,589 calls, rt_call 296,968 to 132,227: the constants' part, with
the generated code's 14.9 and the glue's 5.7 about 80 against the 65
estimated), the helpers' glue 130.9 to 125.2, the records 208.1 to
206.8, the natives 358.8 to 358.2, the hashing 219.8 to 219.9, the
comparisons 124.0 to 123.9, the texts and copies 121.1 to 121.0, the
load 46.2 to 46.0, the iterators 40.6 to 40.3. tools/ratio.py under
WSL on the same binaries gives 1.9, 1.6 and 2.9 by wall-clock, the best
of five, but the reference's rows there are the file reads through
/mnt/d (266.8 ms for a check of 441.6 million instructions), so the
ratio by instructions is the one recorded, as AW1 (2) fixed. AT1's rows
on the frozen self-check (tools/measure_size.sh under WSL, the binary
before against this one): the synchronous JIT row 6,237.9 to 6,013.9
million instructions (-3.6%) and 8,883.9 to 8,659.1 million by the
estimate (-2.5%), the image row 4,742.8 to 4,538.9 (-4.3%) and 6,943.9
to 6,690.1 by the estimate (-3.7%), the cached run 4,821.3 to 4,618.7
(-4.2%), the interpreter 11,451.3 to 11,240.2 (-1.8%) and 15,726.1 to
15,399.6 by the estimate (-2.1%); the image 8,947,664 to 8,945,136
bytes. The four benchmarks and hello by user-space instructions (perf
stat, the JIT synchronous, in millions): primes 289.1 to 288.8,
strings 433.5 to 430.1 (-0.8%), records 236.5 to 209.4 (-11.5%),
json_round_trip 872.7 to 838.1 (-4.0%), hello 5.67 to 5.42 (-4.4%).
The four judges byte-equal, the conformance suite 55 of 55 on both
tiers, the template tier's own tests with the tier forced, 384 tests.
Found on the way and fixed in a2c4685 before this stage's commit: on
Windows every run of an image had the mapping of its code section
refused ("access denied": a mapping with PAGE_EXECUTE_READ needs
GENERIC_EXECUTE on the handle, which File::open does not ask) and
copied the section instead since decision AT5, which the two tests of
crates/renyi/tests/build.rs that assert "mapped from the file" showed
on the owner's machine; image::open_file opens for reading and, on
Windows, execution, the executable of decision AS4 opens itself the
same way, and the report names a refused mapping with the system's
reason.
AW3. Stage 1a of the new backend: a typed parameter's boxed operand
taken from the stack at the call site. The first item of stage 1 in
AW1's order, on 2026-10-11, measured as AW1 prescribes against stage
0's binary (2632cde). Before it, the slow calls that remained after
stage 0 were attributed again (the lane's study_map.py, extended to
rank the calls that enter a code object through its trampoline, that is
through the VM's path): 141,577 into 62 code objects, half of them
type_at (69,493), then lex_reserved (18,762), assign_app
(13,546), var_at (7,460), line_layout (7,209), argument (6,501, a
function value through bracketed), module_at, lookup_param,
parameter (a function value), function_at, call_known; every one
but the two function values an Integer parameter whose operand the
generated code holds boxed although the checker typed it Integer: a
variant's field bound by a pattern (when Named(id), when App(id:
actual_id, ...), when some(function_id)), which Unpack pushes
without a type and the slot's Load notes, a maybe after its
otherwise (words.word_codes.get(text) otherwise 0, starts.at(line)
otherwise 0), whose join with the literal is boxed, or a difference of
two such (stop - start). AR3's direct call wanted a typed operand for
a typed parameter and sent these through rt_call at about 435
instructions each (the frame pushed by the VM, the trampoline,
rt_param_int). The change: the direct condition of Op::Call in
native/codegen.rs admits, for a typed parameter, a boxed operand the
checker noted as the parameter's type (noted_kind in
native/infer.rs: the note's type read as abs_of_type reads a
parameter's, so a refined subtype of Integer counts as Integer, as it
does for the parameter); and call_direct tests such an operand's tags
in place before the table lookup (an Integer that is small, a Boolean,
a Float: the same tests unbox_top makes), goes to the helper's path
with the state untouched when one fails (a big or a guarded Integer,
which the trampoline's rt_param_int would have handed to the
interpreter as before), and otherwise reads the payload from the stack
into the register the body's signature takes, leaving the operand on
the stack for the frame push to move into the parameter's slot, where
the trampoline's entry reads it: the slot holds a plain small Integer,
which no leave counts, instead of whatever the stack held. Nothing else
moves: an operand in the middle of the arguments is not shifted out,
which would cost a copy per operand above it; the frame's move is the
same copy the boxed parameters get, and none when every parameter is on
the stack, as in type_at(world, id) and assign_app. The interpreter
and the template tier are untouched, as the study set for 1a (the
template tier passes boxed arguments and the trampoline unboxes them);
no format changes. The test: crates/renyi_vm/tests/native.rs, an
Integer, a Boolean and a Float parameter each called with a variant's
field bound by a pattern and with a maybe after its otherwise, a
big Integer through the same site, both tiers equal to the interpreter;
the IR of the caller shows the two tag tests and the branch to the
helper's path before the table lookup, the payload read before the
frame push. The measure (callgrind under WSL on the release build for
Linux, the images built under valgrind --tool=none, against stage 0's
binary measured the same way in AW2, the reference AU34's 44782aa): the
check row 2,889.9 to 2,826.6 million instructions (-2.2%; the study
estimated 65 million after stage 0, 2.1%), the parse row 1,162.8 to
1,152.9 (-0.9%), the compile row 4,608.8 to 4,535.7 (-1.6%); the ratios
by instructions against the reference's rows (441.6, 284.7 and 365.6)
6.40, 4.05 and 12.41 against the gate's 3 (6.54, 4.08 and 12.61 after
stage 0); the Rust front end's own rows unchanged (check 173.2,
parse --json 246.7, compile 444.9). The calls through the
trampolines 141,577 to 9,380 (call_from_stack 141,589 to 9,392,
rt_call 132,227 to 30): what remains is the parser's function values
(argument 6,501, parameter 1,952, field_pattern 463,
variant_field 275, expression 170, each the item parser bracketed
and its kin take as a value, rt_call_value) and the eleven module
constants the run builds at their first read. The check row by
category, AW2's table against this one, in millions: the generated code
996.9 to 994.9, the calls through the VM's path 57.3 to 7.4 (the
stage's part, 49.9, with the glue's 4.5, the counts' 3.8, the natives'
2.3, the generated code's 2.0 and the copies' 0.7 about 63 against the
65 estimated), the helpers' glue 125.2 to 120.7, the counts and drops
444.5 to 440.7, the natives 358.2 to 355.9, the texts and copies 121.0
to 120.3, mimalloc 146.8 both, the records 206.8 both, the hashing
219.9 to 219.8, the comparisons 123.9 both, the load 46.0 both, the
iterators 40.3 both. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, stage 0's binary against this one):
the synchronous JIT row 6,013.9 to 6,008.2 million instructions (-0.1%)
and 8,659.1 to 8,640.4 million by the estimate (-0.2%), the image row
4,538.9 to 4,496.7 (-0.9%) and 6,690.1 to 6,622.5 by the estimate
(-1.0%), the cached run 4,618.7 to 4,576.3 (-0.9%), the interpreter
11,240.2 to 11,240.5 (unchanged); the image 8,945,136 to 9,008,656
bytes (the tag tests, 173.9 bytes of body per op from 172.5). The four
benchmarks and hello by user-space instructions (perf stat, the JIT
synchronous) are unchanged to the sixth figure (primes 288.8 million,
strings 430.1, records 209.4, json_round_trip 838.1, hello
5.42): no such site lies on their paths. The four judges byte-equal,
the conformance suite 55 of 55 on both tiers, the template tier's own
tests with the tier forced, 385 tests. Stage 1c next, the leave by the
static ownership state: on this binary 917,264 frames still leave
through rt_truncate, 301.5 million inclusive, finding 2's target.
AW4. Stage 1c of the new backend: the frame's leave by the static
ownership state of the slots. The second item of stage 1 in AW1's
order, on 2026-10-11, measured as AW1 prescribes against stage 1a's
binary (7bb927b). Finding 2 of the study: a third of the frames left
through rt_truncate (917,264 leaves, 301.5 million instructions
inclusive on stage 1a's binary, 10.7% of the check row), which cuts the
stack to the frame's base and drops every slot by its tag at run time,
because the leave in place released a frame's locals one by one only
when the slots that are not typed, with the boxed operands above them,
were at most four (RELEASES_INLINE), and the callers with many locals
(next_step, resolve, substitute, lex_word, expr_span,
find_binding) went to the helper although AU55's moves leave most of
their slots holding Nothing at the return. The change: owned_slots
in native/infer.rs computes, per op, the slots that may hold a
counted block on entry to it, as a fixed point over the ops' flow with
the analysis's entry states and handler regions: a boxed parameter from
the entry; a boxed slot from the store of anything but a plain scalar
until the LoadMove that moves it out (a moved load a typed call or a
comparison borrows keeps the slot's value, decision AU17, and counts as
no move) or the WithSlot that moves the record out; a slot of another
kind (an iterator, a deadline, a mark) always, a typed slot never; a
failure flows to its handler with the state before the op; an op the
analysis does not reach has every slot counted. The leave in place
(leave_frame_inline in native/codegen.rs, and the boxed result's
leave through it) releases the slots so counted at the return's op,
with the boxed operands above the locals, inline when they are at most
eight (RELEASES_INLINE four to eight, the study's figure), and calls
rt_truncate otherwise; a slot skipped holds Nothing or a plain
value, which the interpreter's own leave by tags would have found
nothing to drop in either. The interpreter and the template tier are
untouched: the interpreter writes the slots as the same ops say, so a
frame it hands over at a loop header fits the state there, and the
template tier's return still goes through rt_return, which drops by
tags (its leave by the same analysis is left for a later stage, the
measure being the check row); no format changes. The tests:
crates/renyi_vm/tests/native.rs, a frame with thirteen locals (texts,
a list, a record updated, a failing call caught by otherwise) left by
three returns, both tiers equal to the interpreter; and
crates/renyi/tests/sandbox.rs, the same frame left two hundred
thousand times under a memory budget of sixteen megabytes on both
tiers, through the binary, which a slot skipped wrongly would exceed (a
run that keeps every result alive does, checked by hand); the IR of the
frame shows no call of rt_truncate and the releases inline. The
measure (callgrind under WSL on the release build for Linux, the images
built under valgrind --tool=none, against stage 1a's binary measured
the same way in AW3, the reference AU34's 44782aa): the check row
2,826.6 to 2,729.4 million instructions (-3.4%; the study estimated 200
million, 6.5%), the parse row 1,152.9 to 1,132.9 (-1.7%), the compile
row 4,535.7 to 4,395.7 (-3.1%); the ratios by instructions against the
reference's rows (441.6, 284.7 and 365.6) 6.18, 3.98 and 12.02 against
the gate's 3 (6.40, 4.05 and 12.41 after stage 1a); the Rust front
end's own rows unchanged (check 173.4, parse --json 246.7,
compile 445.6). The leaves through rt_truncate 917,264 to 32,514
(16.0 million inclusive, from 301.5); the drops out of line through
rt_drop_at, the last reference's, 150,010 to 668,735 calls (201.1
million inclusive, from 34.3): the frees the helper's loop made are
made one by one now, which is why the gain is 97 million against the
200 the study estimated, the study having counted the helper's
inclusive cost as the leave's where the drops of the last references
are the values' own cost and remain; the leave itself fell from about
329 instructions to about 20. The check row by category, AW3's table
against this one, in millions: the generated code 994.9 to 1,014.6, the
counts and drops 440.7 to 321.9, the helpers' glue 120.7 to 120.7, the
calls through the VM's path 7.4 to 7.4, mimalloc 146.8 to 146.8, the
records 206.8 to 206.8, the natives 355.9 to 355.9, the hashing 219.8
to 221.8, the comparisons 123.9 to 123.9, the texts and copies 120.3 to
120.3, the load 46.0 to 46.0, the iterators 40.3 to 40.3. AT1's rows on
the frozen self-check (tools/measure_size.sh under WSL, stage 1a's
binary against this one): the synchronous JIT row 6,008.2 to 5,981.1
million instructions (-0.5%) and 8,640.4 to 8,622.5 by the estimate
(-0.2%), the image row 4,496.7 to 4,376.1 (-2.7%) and 6,622.5 to
6,507.6 by the estimate (-1.7%), the cached run 4,576.3 to 4,455.7
(-2.6%), the interpreter 11,240.5 to 11,240.4 (unchanged); the image
9,008,656 to 9,837,312 bytes (+9.2%: the releases inline at every
return, 191.8 bytes of body per op from 173.9). The four benchmarks and
hello by user-space instructions (perf stat, the JIT synchronous, in
millions): primes 288.8 to 288.9 (+0.0%), strings 430.1 to 429.9
(-0.0%), records 209.4 to 208.9 (-0.2%), json_round_trip 838.1 to
839.6 (+0.2%), hello 5.42 to 5.42 (unchanged). The four judges
byte-equal, the conformance suite 55 of 55 on both tiers, the template
tier's own tests with the tier forced, 387 tests. Stage 1b next, the
read-only flag per parameter in the bytecode, then 1d.
AW5. Stage 1b of the new backend: a read-only parameter passed
borrowed between compiled bodies. The third item of stage 1 in AW1's
order, on 2026-10-12, measured as AW1 prescribes against stage 1c's
binary (1cfcd7d). The study's item (1b): a direct call retained every
boxed argument at the caller's Load and the callee released it at its
leave, a pair of count operations per argument on 2,770,541 calls with
about one and a half such arguments each, although most parameters are
only read. The flag, as AW1 (4) chose: Code gains read_only, a
Boolean per parameter, in the bytecode file (file.rs, format 7 to 8,
after locals), the binary encoding (binary.rs, 4 to 5), the image
(image.rs, image format 8 to 9, code format 15 to 16) and
compiler/bytecode.ry; both emitters compute it from the finished ops
(Code::read_only_params in bytecode.rs, called by the Rust
emitter's finish; read_only_params in compiler/emit.ry), held
equal by the compile judge: a parameter is read-only when no op writes
its slot, no Store, WithSlot, TakeField, IterInit, Deadline
or MarkStack. A LoadMove does not disqualify the flag, where the
study's rule had it: AU55 makes the last read of nearly every parameter
a move, so the study's rule would have flagged almost none; which moves
a borrow tolerates is the tier's question, answered below. On the
checker's own program, 2,133 of its 2,328 parameters are read-only; 177
are not for a TakeField (166 for that alone: a record read once
through a field on its last use, as AU55 compiles it, which a
TakeField that clones when the slot is borrowed could admit later)
and 29 for a WithSlot. The protocol in native/codegen.rs: the
body's signature (direct_signature) gains an i64 after the direct
flag, the bits of the parameters the caller passed borrowed, which a
trampoline passes as zero; borrowed_operands marks, for a Call that
direct_call (the condition of AR3 and AW3, now one function for the
analysis and the emission) makes directly, the plain Loads and the
boxed Consts among its last arguments whose parameter the callee
accepts borrowed (accepted_params, below), stepping over a typed push
(one operand, in a register), and the mask per call; the caller's push
of a marked operand carries no reference, as a typed call's does (AU1,
AU17), and call_direct passes the mask, or gives the marked operands
a reference first on its path through rt_call, as the call through
the VM's path does when the emission does not take the direct call the
analysis expected. A moved load, the caller's last use of the slot, is
not borrowed by a direct call but moved into the callee as before: the
first build borrowed it too, as a typed call does, and measured 4.5%
more instructions on the check row (2,851.6 million against 2,729.4;
the counts and drops 321.9 to 424.4, the natives 355.9 to 385.6), the
callee's copy of the value then having two references where the moved
one had one, so that every append or update of a list or a record
passed by its last use copied it and the caller's leave freed the old
one (the measure is kept as the lane's study/stage1b_moves_borrowed).
Which parameters a call may pass borrowed is one rule both sides read,
accepted_params in native/codegen.rs: boxed, read-only, among the
first thirty-two, and never moved into an owned sink, that is, every
LoadMove of the slot (in the program as the VM prepares it, its last
reads moves, AU17) is an argument of a call through a typed entry or an
operand of a comparison, which read the value where it lies; computed
from the code object's ops and the program's tables alone, so that a
caller's compilation, on the compile thread or for an image, reads the
same bits the callee's does, which the protocol requires. The second
build accepted every boxed read-only parameter and had the callee move
conditionally, a LoadMove of such a parameter testing its bit to move
when the frame owned the slot or to copy with a reference when the
caller did; it measured the check row at 2,723.4 million, 0.2% under
stage 1c, and AT1's estimate 0.1% over it (kept as the lane's
study/stage1b_conditional_moves): AU55 makes most arguments moves,
which a direct call cannot borrow, so the pairs saved were those of
plain loads and constants alone, and the conditional move of every
flagged parameter cost about half of what they saved. The owner's
answer of 2026-10-12: refine first, accepting a borrow only for a
parameter never moved into an owned sink, then decide by the measure,
the stage reverted whole if the check row still falls by less than 0.5%
and AT1's estimate does not fall. In the callee now, a LoadMove of an
accepted parameter is one a typed entry or a comparison borrows, and
moves nothing; the conditional move remains as the fallback where the
analysis finds such a move owned after all (a comparison whose other
operand is typed); the leave in place releases an accepted slot only
when its bit is clear (owned_slots is unchanged); and every way out
that treats the frame as owned gives the borrowed slots a reference
first through the new helper rt_retain_params (a hand-back before
rt_deopt, the leave through rt_truncate, rt_fail,
rt_check_failed, rt_unhandled, and an interrupt at the exit, whose
frame the caller's abandon drops). The interpreter is untouched; the
template tier stays on the owned protocol and says so to
borrowed_operands (its switch direct_calls), which the first build
did not: the template tier shares the analysis, pushed the marked
operands without a reference and passed the frame owned through its own
call, a double free found by the test program's run with
RENYI_NATIVE_TIER=template (a segmentation fault; the same run under
a memory budget passed, the counting allocator hiding it). The tests:
crates/renyi_vm/tests/native.rs, two thousand turns of ten paths out
of a frame holding a borrowed parameter (a field read, two parameters
read into a text, the parameter returned, passed on borrowed again and
into a record, a record updated by with beside a borrowed one, a
failure caught by the caller, one propagated through otherwise fail,
a hand-back after the read at an overflow, a temporary beside a
borrowed argument, the reads in a loop), both tiers equal to the
interpreter, the masks of main's eleven direct calls read from its IR
(1 for a record read by its fields beside a text whose move goes into
an interpolation, 1 for a text whose only move goes into Text.length,
passed on borrowed again by its callee, 2 for a record beside a list
passed by its last use, 0 where the parameter is returned, passed on by
a last use, constructed into a record or updated by with, where its
last read takes a field, or where the argument is a temporary or a last
use); and crates/renyi/tests/sandbox.rs, the same forty thousand
times under a memory budget of sixteen megabytes through the binary on
both tiers, and a crash inside a frame holding a borrowed parameter,
which exits with the crash. The compile tests' literal format numbers
moved up by one. The measure (callgrind under WSL on the release build
for Linux, the images built under valgrind --tool=none, against stage
1c's binary measured the same way in AW4, the reference AU34's
44782aa): the check row 2,729.4 to 2,719.3 million instructions (-0.4%;
the study estimated 80 million, 2.6%), the parse row 1,132.9 to 1,128.1
(-0.4%), the compile row 4,395.7 to 4,403.4 (+0.2%); the ratios by
instructions against the reference's rows (441.6, 284.7 and 365.6)
6.16, 3.96 and 12.04 against the gate's 3 (6.18, 3.98 and 12.02 after
stage 1c); the Rust front end's own rows within 0.2% of stage 1c's (check 173.6,
parse --json 246.7, compile 446.7). The helpers on the check row:
rt_retain_params 330,192 instructions (0.01%; the borrowed slots
given a reference before a hand-back or a leave through a helper;
763,432 in the second build), rt_truncate 16.0 million (0.6%),
rt_drop_at 201.1 million (7.4%), the last two as in stage 1c. The
check row by category, AW4's table against this one, in millions: the
generated code 1,014.6 to 1,004.1, the counts and drops 321.9 to 322.2,
the helpers' glue 120.7 to 120.7, the calls through the VM's path 7.4
to 7.4, mimalloc 146.8 to 146.9, the records 206.8 to 206.8, the
natives 355.9 to 355.9, the hashing 221.8 to 221.5, the comparisons
123.9 to 123.9, the texts and copies 120.3 to 120.3, the load 46.0 to
46.2, the iterators 40.3 to 40.3. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, stage 1c's binary against this
one): the synchronous JIT row 5,981.1 to 5,975.3 million instructions
(-0.1%) and 8,622.5 to 8,590.5 by the estimate (-0.4%), the image row
4,376.1 to 4,358.8 (-0.4%) and 6,507.6 to 6,409.7 by the estimate
(-1.5%), the cached run 4,455.7 to 4,438.7 (-0.4%), the interpreter
11,240.4 to 11,241.1 (+0.0%); the image 9,837,312 to 9,833,784 bytes
(-0.0%, 3,528 bytes under stage 1c's, where the second build's
conditional moves had added 394,024, 4.0%). The four benchmarks and
hello by user-space instructions (perf stat, the JIT synchronous, in
millions): primes 288.9 to 289.2 (+0.1%), strings 429.9 to 433.3
(+0.8%), records 208.9 to 209.0 (+0.0%), json_round_trip 839.6 to
839.6 (unchanged), hello 5.42 to 5.42 (unchanged). The four judges
byte-equal, the conformance suite 55 of 55 on both tiers, the template
tier's own tests with the tier forced, 389 tests. Stage 1d next, the
frame record made cheaper.
AW6. Stage 1d of the new backend: the frame record made cheaper.
The fourth and last item of stage 1 in AW1's order, on 2026-10-12,
measured as AW1 prescribes against stage 1b's binary (2367c63). The
study's item (1d): at every direct call, push_frame_inline read the
caller's grant from the frame record on top (the frames' pointer and
length loaded, the record's address computed, the grant loaded),
checked the stack's capacity for the callee's locals and wrote the
stack's length, and checked the frames' capacity for one more record,
about 45 instructions with the depth guard where the record's five
words cost a few. Three changes in native/codegen.rs, the interpreter
untouched and the template tier as it was (its push follows the
interpreter's protocol, clearing the callee's locals and writing the
length itself, since its callee may be template code with no prologue
of its own; a grant in a register there would change the Entry
signature through Vm::run_generated, for code that runs only until
the Cranelift code is ready, which the measure does not see): (i) the
frame's grant (decision Q1, an index into Vm::grants) travels in the
body's signature (direct_signature, an i32 after the borrowed
bits), a direct caller passing its own, which it holds in a register
from its entry, or the helper's answer (rt_frame_grant) when the
callee narrows the grant, and the trampoline reading it from the record
on top; the call site writes the callee's record from the register;
(ii) the stack's length, which the call site wrote as the callee's base
plus its locals after a check of the capacity, is written by the
callee's prologue instead, after the check it makes anyway for its
locals and its deepest operand stack (AR4), the call site leaving the
length at the arguments; the exception is a boxed argument that moves
to a slot past the room the caller's prologue made (a typed parameter
before a boxed one, called at the caller's deepest operand), which
keeps the check at the site; (iii) the frames' capacity for the record
a direct call pushes is checked once, in the prologue of a body that
makes a direct call (has_direct_call), since the frames' length is
the same at every one of its calls, this frame on top, and the capacity
never falls. The code format is 17. On the test program of AW5,
main's eleven direct calls, the IR fell from 4,699 to 4,405
instructions by a count of its lines. The tests: the program of every
shape of direct call (a callee that narrows the grant called from
main and from another that narrows, a callee that inherits the grant
and calls on, recursion past the frames' capacity and the depth limit,
typed parameters before a boxed one at the caller's deepest operand) in
crates/renyi_vm/tests/native.rs against the interpreter, in
crates/renyi_vm/tests/template.rs on the template tier, and in
crates/renyi/tests/sandbox.rs through the binary under a memory
budget of sixteen megabytes on both tiers; its main's IR calls
rt_grow_frames and rt_room once each, in the prologue, and
rt_frame_grant twice, for the two narrowing callees. The measure
(callgrind under WSL on the release build for Linux, the images built
under valgrind --tool=none, against stage 1b's binary measured the
same way in AW5, the reference AU34's 44782aa): the check row 2,719.3
to 2,681.0 million instructions (-1.4%; the study estimated 55 million,
1.8%), the parse row 1,128.1 to 1,116.1 (-1.1%), the compile row
4,403.4 to 4,352.4 (-1.2%); the ratios by instructions against the
reference's rows (441.6, 284.7 and 365.6) 6.07, 3.92 and 11.90 against
the gate's 3 (6.16, 3.96 and 12.04 after stage 1b); the Rust front
end's own rows within 0.3% of stage 1b's (check 173.1, parse --json
246.7, compile 446.3). The helpers on the check row run as in stage
1b: rt_frame_grant 54,165 instructions (the narrowing callees'
grants), rt_room 17,926 and rt_grow_frames 1,215 (the growths, now
from the prologues), rt_retain_params 330,192, rt_call 378.1
million, rt_truncate 16.0 million, rt_drop_at 201.1 million; the
whole fall is in the generated code. The check row by category, AW5's
table against this one, in millions: the generated code 1,004.1 to
966.7, the counts and drops 322.2 to 322.2, the helpers' glue 120.7 to
120.7, the calls through the VM's path 7.4 to 7.4, mimalloc 146.9 to
146.9, the records 206.8 to 206.8, the natives 355.9 to 355.9, the
hashing 221.5 to 220.5, the comparisons 123.9 to 123.9, the texts and
copies 120.3 to 120.3, the load 46.2 to 46.2, the iterators 40.3 to
40.3. AT1's rows on the frozen self-check (tools/measure_size.sh
under WSL, stage 1b's binary against this one): the synchronous JIT row
5,975.3 to 5,897.8 million instructions (-1.3%) and 8,590.5 to 8,484.1
by the estimate (-1.2%), the image row 4,358.8 to 4,288.4 (-1.6%) and
6,409.7 to 6,288.7 by the estimate (-1.9%), the cached run 4,438.7 to
4,368.2 (-1.6%), the interpreter 11,241.1 to 11,241.3 (+0.0%); the
image 9,833,784 to 9,009,552 bytes (-8.4%: the bodies 8,831,433 to
7,981,545 bytes without the call sites' checks and the grant's loads,
the trampolines 156,448 to 186,616 with the grant's read). The four
benchmarks and hello by user-space instructions (perf stat, the JIT
synchronous, in millions): primes 289.2 to 265.0 (-8.4%), strings
433.3 to 432.5 (-0.2%), records 209.0 to 207.0 (-1.0%),
json_round_trip 839.6 to 839.7 (+0.0%), hello 5.42 to 5.42
(unchanged). The four judges byte-equal, the conformance suite 55 of 55
on both tiers, the template tier's own tests with the tier forced, 392
tests. Stage 1 is complete: the check row 2,889.9 million after stage 0
to 2,681.0, -7.2%, against the study's estimate of 400 million, 13%, by
the findings' counts. Next in AW1's order: the character tables and the
hasher.
AW7. The character tables and the hasher of the VM's own. The item
after stage 1 in AW1's order (the study's items (3b) and (3c), the
owner's answer (7)), on 2026-10-12, measured as AW1 prescribes against
stage 1d's binary (ddbf36a). Two changes to the natives and one to the
maps and sets, the generated code untouched. (i) run_of and
run_until (decision AU52, the lexer's scans over a character class)
scan with a table of 128 bits of the set's members that are texts of
one ASCII character (ascii_members in natives/prelude.rs): such an
item is a member exactly when its bit is set, since it equals a member
only when the member is that text, and any other item asks the set as
before. Measured alone, the tables took the check row from 2,681.0 to
2,621.5 million (-2.2%) and the hashing from 220.5 to 96.2, but the
natives from 355.9 to 420.7: the table was built per call over the
sixty-odd members of a class, about a thousand instructions a call,
70.0 million over list_run_of_typed's 53,046 calls. So (ii) the
tables of the sets scanned last are kept, eight at most, in a
thread-local list with the set each belongs to, whose address names it
while the entry holds it (class_table); the VM clears the list when
it is dropped. (iii) The maps and sets of values (Value::Map,
Value::Set) hash with a hasher of the VM's own (hashing.rs:
ValueHasher, ValueHashing, the aliases ValueMap and ValueSet
every site uses) in place of the standard library's SipHash, whose
write cost a hundred instructions and more for the one to twelve
bytes of a typical key: one state word, every word written folded in by
a multiplication whose 128-bit product is folded to 64 bits, so that
every bit of the state depends on every bit written; a span of bytes
read as two overlapping words (the first and last eight, the first and
last four, or the first, middle and last byte of a shorter span,
sixteen at a time before that), its length in the multiplier, so that
spans whose overlapping reads agree ("aaaa" and "aaaaa") hash apart;
the state starts from a key drawn once per process from the standard
library's RandomState, so that keys chosen to collide in one run do
not collide in the next, the defence SipHash's keys give a server
against a flood of colliding keys, though a multiplication is easier to
reverse than SipHash once the key is known, a trade the owner may
revisit by a decision. The order of a map or a set is the order of
insertion (IndexMap), so the hash is not observable by a program;
Value.hash() (vm::hash_of) keeps the standard hasher with its fixed
keys, being a number a program reads. The tests: hashing.rs's own
(spans of one character repeated zero to forty times hash apart
pairwise, as do a text and its prefix and two long texts differing in a
byte, and the key holds across hashers), value.rs's set test through
ValueSet, the judges and the conformance suite, and the lexer's
tokens equal on a probe with text outside ASCII. The measure (callgrind
under WSL on the release build for Linux, the images built under
valgrind --tool=none, against stage 1d's binary measured the same way
in AW6, the reference AU34's 44782aa): the check row 2,681.0 to 2,527.2
million instructions (-5.7%), the parse row 1,116.1 to 1,040.1 (-6.8%;
the tables alone 1,082.4, -3.0%), the compile row 4,352.4 to 4,148.8
(-4.7%); the ratios by instructions against the reference's rows
(441.6, 284.7 and 365.6) 5.72, 3.65 and 11.35 against the gate's 3
(6.07, 3.92 and 11.90 after stage 1d); the Rust front end's own rows
within 0.1% of stage 1d's (check 173.2, parse --json 246.7,
compile 446.1). The functions on the check row, inclusive:
list_run_of_typed 125.2 million over 53,046 calls in stage 1d, 70.0
with the table built per call, 16.1 with the tables kept (class_table
2.5); the hashes of a Value 547,511 in stage 1d at 244 instructions
each (hash_one 133.9 million, SipHash's write 59.7 over 1,589,797
calls), 207,134 with the tables, the scans no longer hashing, and 12.3
million in all with the hasher, 59 each; the set lookups
(get_index_of) 429,399 to 20,129, the map lookups 126,054 as before;
Value::eq 42.3 million over 1,011,987 calls to 23.2 over 642,529, the
lookups' comparisons; SipHash's write 0.4 million left, in the VM's
own tables keyed by usize. The check row by category, AW6's table
against this one, in millions: the natives 355.9 to 366.9, the hashing
220.5 to 55.5, the generated code 966.7 to 966.7, the counts and drops
322.2 to 322.2, the helpers' glue 120.7 to 120.7, the calls through the
VM's path 7.4 to 7.4, mimalloc 146.9 to 147.1, the records 206.8 to
206.8, the comparisons 123.9 to 123.8, the texts and copies 120.3 to
120.3, the load 46.2 to 46.2, the iterators 40.3 to 40.3. AT1's rows on
the frozen self-check (tools/measure_size.sh under WSL, stage 1d's
binary against this one): the synchronous JIT row 5,897.8 to 5,880.1
million instructions (-0.3%) and 8,484.1 to 8,428.0 by the estimate
(-0.7%), the image row 4,288.4 to 4,270.5 (-0.4%) and 6,288.7 to
6,266.7 by the estimate (-0.3%), the cached run 4,368.2 to 4,350.4
(-0.4%), the interpreter 11,241.3 to 11,223.5 (-0.2%); the image
9,009,552 to 9,009,552 bytes (unchanged). The four benchmarks and hello
by user-space instructions (perf stat, the JIT synchronous, in
millions): primes 265.0 to 265.0 (unchanged), strings 432.5 to
432.5 (unchanged), records 207.0 to 207.0 (unchanged),
json_round_trip 839.7 to 839.7 (unchanged), hello 5.42 to 5.42
(unchanged). The four judges byte-equal, the conformance suite 55 of 55
on both tiers, the template tier's own tests with the tier forced, 394
tests. Since stage 0 the check row 2,889.9 to 2,527.2 (-12.5%), since
the study's binary 3,085.3 (-18.1%). Next in AW1's order: stage 2, 2a
first (with by static index with the copy in place).
AW8. Stage 2a of the new backend: the update by static index. The
first item of stage 2 in AW1's order (the study's item (2a)), on
2026-10-12, measured as AW1 prescribes against the hasher's binary
(94089f9). A with ran through rt_with or rt_with_slot (decision
AU11), which popped the pairs into a vector, looked every field up by
name (field_index, a scan of the type's fields comparing texts),
checked the refinements and pushed the result: about a thousand
instructions a call, 212.4 million on the check row over 201,205 calls.
Where the checker typed the with (AU1's annotation on the op, which
pushes its expression), the generated code knows the record's type, so
update_by_index in native/infer.rs settles at compile time the type
and the index of every updated field: the op's annotation names a
record type without refinements and not Date, and the name of each
update is the text the Const at its depth pushed, found through the
analysis's states (every op between that Const and the with lies
deeper), the indices packed eight bits each with the count in the top
byte, at most seven updates; anything else keeps the helpers by name.
Built in two parts, each measured. (A) A helper that takes the type and
the packed indices (rt_with_by_index, rt_with_slot_by_index,
Vm::op_with_by_index): a holder that is a record of the type with
plain new values is updated at the indices, in place when held once and
in a copy otherwise, with no vector, no lookup and no refinement check;
a holder of another kind or a guarded new value goes the general way.
Both tiers call it, the template tier for good (the study's "a helper
that takes the indices"). (B) On the Cranelift tier the update compiled
into the site (update_in_place in native/codegen.rs): the pairs
boxed, the holder's tag and type and the new values' tags tested in
place, the block updated where it lies when its count is one and a copy
of it (rt_record_copy, the fields cloned, the holder's reference
given up) otherwise, each field's old value released in place (AU32's
sequence) and the new value moved in, each name released, the record
left where the first name lay (where the holder lay, for With) and
the slot left Nothing; the helper of (A) in a cold block for the
rest, leaving the same stack. The code format is 18. The tests: the
program of every shape (a parameter's record shared with the caller, a
record held once in its slot through a loop, field names longer than a
small text, a refined type and an update of eight fields through the
general helper, a fresh record updated each turn) in
crates/renyi_vm/tests/native.rs against the interpreter and in
crates/renyi_vm/tests/template.rs on the template tier. The measure
(callgrind under WSL on the release build for Linux, the images built
under valgrind --tool=none, against the hasher's binary measured the
same way in AW7, the reference AU34's 44782aa). With (A) alone, both
tiers on the helper: the check row 2,527.2 to 2,416.7 million
instructions (-4.4%), the parse row 1,040.1 to 994.0 (-4.4%), the
compile row 4,148.8 to 3,992.6 (-3.8%); the records category 206.8 to
142.7, the helpers' glue 120.7 to 99.5, mimalloc 147.1 to 135.6, the
counts and drops 322.2 to 315.4, the texts and copies 120.3 to 112.7;
rt_with_slot_by_index 72.6 million inclusive and rt_with_by_index
28.6 against 162.7 and 49.7 for the helpers by name, make_mut 41.2
(the copies of shared bases); AT1's synchronous row -1.5% (-1.4% by the
estimate). With (B), the update compiled into the site: the check row
2,527.2 to 2,370.7 (-6.2%), the parse row 1,040.1 to 974.3 (-6.3%), the
compile row 4,148.8 to 3,934.1 (-5.2%); the ratios by instructions
against the reference's rows (441.6, 284.7 and 365.6) 5.37, 3.42 and
10.76 against the gate's 3 (5.72, 3.65 and 11.35 after AW7); the Rust
front end's own rows within 0.1% of the hasher's (check 173.4, parse
--json 246.7, compile 446.3). The functions on the check row: with
(A), op_with_by_index 89.1 million inclusive over 201,205 calls (443
each, against about 1,050 by name), make_mut 41.2 of them, the copies
of the shared bases; with (B), the helpers by index are never called on
this row (the site's tests always pass), rt_record_copy 38.3 million
inclusive over 126,606 calls (the bases held by another value at the
update, 63 of 100, 302 each with the allocation and the fields'
clones), Value's drop glue 14,611,263 calls to 13,282,873,
rt_drop_at 668,735 to 683,178 (the old field values released in place
that reach zero), the generated code 966.7 to 980.4 million with the
sequences, which the records' fall pays for nine times over; on the
frozen self-check the sequences cost what the helper saved, (A) -1.5%
and (B) -1.3% on the synchronous row, the check row deciding (AW1). The
check row by category, AW7's table against this one, in millions: the
records 206.8 to 79.9, the generated code 966.7 to 980.4, the helpers'
glue 120.7 to 92.7, mimalloc 147.1 to 135.7, the counts and drops 322.2
to 306.8, the texts and copies 120.3 to 112.7, the natives 366.9 to
366.9, the hashing 55.5 to 55.6, the calls through the VM's path 7.4 to
7.4, the comparisons 123.8 to 123.8, the load 46.2 to 46.2, the
iterators 40.3 to 40.3. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, the hasher's binary against this
one): the synchronous JIT row 5,880.1 to 5,802.0 million instructions
(-1.3%) and 8,428.0 to 8,356.3 by the estimate (-0.9%), the image row
4,270.5 to 4,140.7 (-3.0%) and 6,266.7 to 6,084.3 by the estimate
(-2.9%), the cached run 4,350.4 to 4,220.6 (-3.0%), the interpreter
11,223.5 to 11,229.0 (+0.0%); the image 9,009,552 to 9,137,440 bytes
(+1.4%). The four benchmarks and hello by user-space instructions
(perf stat, the JIT synchronous, in millions): primes 265.0 to
265.0 (unchanged), strings 432.5 to 432.5 (unchanged), records
207.0 to 207.0 (unchanged), json_round_trip 839.7 to 839.7
(unchanged), hello 5.42 to 5.42 (unchanged). The four judges
byte-equal, the conformance suite 55 of 55 on both tiers, the template
tier's own tests with the tier forced, 396 tests. Since stage 0 the
check row 2,889.9 to 2,370.7 (-18.0%), since the study's binary 3,085.3
(-23.2%). Next in AW1's order: stage 2b, Done without its allocation.
AW9. Stage 2b of the new backend: a record of two fields returned as
a pair. The second item of stage 2 in AW1's order (the study's item
(2b), Done without its allocation, which AW1 (5) settled as a
convention per function), on 2026-10-12, measured as AW1 prescribes
against stage 2a's binary (1ad4399). A function whose declared result
is a record of two fields (the checker's Done, the parser's Parsed,
the emitter's Built: 275 such functions with a code object in the
checker's program, 105 of them returning Done and 100 Parsed)
constructed it on its way out (rt_construct: the block allocated, the
fields moved in), and its caller took the fields out at once and freed
it: 677,653 constructs, 683,178 releases through rt_drop_at,
1,084,633 frees of a block (the nested ones counted) on the check row
of AW8's build. The convention per function: a function whose declared
result is a record of exactly two fields of a type without refinements
and not Date, with a code object, is a pair function (pair_result
in native/infer.rs); on the Cranelift tier its body answers a direct
caller with the two fields in the first two cells of where its frame
was, with D_RETURNED (pair_return in native/codegen.rs: the
fields' words read before the leave, the frame left, the words written,
the stack's length two above the base), and answers the trampoline's
caller, and any caller under provenance guards (the record then carries
the union of the fields' origins), with the record and D_BOXED, as
Construct would have made it; before the Return a Construct of
the type leaves its two fields as they lie (no block), a call of a pair
function passes its pair on, a load of a pair slot pushes its cells,
and anything else is a record taken apart (rt_split_pair: moved out
of a record held once, copied from a shared one, each field with the
record's origins under guards). On the caller's side the abstract
operand Abs::Pair of two cells, with the record's type, is what a
call of a pair function leaves when the op after takes the pair as it
lies (pair_fused: a Store, a Field or a Return), and before any
other op it becomes its record (rt_pair_record, in place), so that a
pair never lies under another operand; a Store of a pair into a slot
stored from pairs alone makes a pair slot (SlotKind::Pair: the first
field in the slot, the second in a cell of the frame past the code
object's locals, frame_locals in the generator; a slot stored into
with anything else holds records, join_slot); LoadField and
TakeField on a pair slot read or move the field's cell (a take at the
slot's last read leaves both cells Nothing); Load and LoadMove
push both cells, copied with a reference each or moved at the last
read; a Field on a pair leaves the field in the lower cell and
releases the other; a WithSlot on a pair slot makes it boxed from
there on. The hand-back (rt_deopt) rebuilds a pair on the stack from
its two cells and a pair slot's record from the slot and its second
cell when the slot holds its pair (an owned word per pair slot in the
point's buffer), and cuts the cells past the locals off. The entry at a
loop header from a frame the interpreter hands over: rt_pair_fits
checks that each pair slot holds a plain record of the type or
Nothing (else the entry is refused with D_STAY), the frame is
widened by the pair cells, and rt_pair_resume takes each record apart
into its cells; on the way the prologue's write of the stack's length
before the header dispatch, which lengthened the stack of an entry
refused after it (a latent defect for the expanded bodies of AU50, hit
here through the second loop of a function whose first loop's finished
range rt_resume_range refuses), is gone: the start path writes the
length after the dispatch, the resume path once its checks have passed.
The template tier calls a pair function through its trampoline, which
answers the record (analyse without pairs), as do the expanded
callees of AU50 and the typed test. The code format is 19 (the pair
kinds with their type in the hand-back points, which
tools/image_census.py reads). Built in two parts, each measured. (A)
The pair at the call alone. The survey of the checker's bytecode: of
the 782 calls of a pair function, 312 are followed by a Store, 100 by
a Return, 34 by a Field, and 244 by the PopHandler of an
otherwise (let done be check(...) otherwise fail, the idiom of the
checker's failure propagation); of the pair functions' returns, 423
return a Construct of the type, 100 a call of a pair function, 88 a
load; 305 slots are stored from pair calls alone. Measured, the check
row 2,370.7 to 2,342.0 million instructions (-1.2%) against the study's
estimate of 4.9%: rt_construct 677,653 to 410,681 calls, but
rt_pair_record 176,261 calls, two pairs of three made into their
record by the caller after all, most at the otherwise: the compiler
closes the handled region after the call with PopHandler and tests
the value (JumpIfFailure to the fallback, then a Jump to the end),
and a pair before the test was boxed for it. (B) The pair past the
test. otherwise_end in native/infer.rs recognises the three ops
after a call that ends a region, and a pair the call leaves takes the
jump to the end at once (the analysis flows the state there with the
region closed, pair_bypass in the generator jumps there), so that the
test is reached through its handler alone, with a failure on top
(handler_only: the region's PopHandler before it on no path), and
its jump is always taken; pair_fused looks at the op at the end.
Where the fallback falls through with a value (otherwise Step(...)),
the states join boxed and the pair becomes its record at the edge, as
before. The tests: the program of every shape (a pair stored and taken
apart, read as a field at once, relayed, kept whole in a list, held
across a loop whose Integer leaves the machine word and hands the frame
back, kept past otherwise fail and returned past one, taken with a
fallback value, on the success path and the failure path; a record of
three fields) in crates/renyi_vm/tests/native.rs against the
interpreter with everything compiled, and in
crates/renyi_vm/tests/promotion.rs promoted from template code (the
trampoline's path, and the entry at a loop header with a pair slot
live). The measure (callgrind under WSL on the release build for Linux,
the images built under valgrind --tool=none, against stage 2a's
binary measured the same way in AW8, the reference AU34's 44782aa).
With (A) alone: the check row 2,370.7 to 2,342.0 million instructions
(-1.2%), the parse row 974.3 to 966.4 (-0.8%), the compile row 3,934.1
to 3,874.0 (-1.5%); the records category 79.9 to 57.7, the generated
code 980.4 to 985.4, the helpers' glue 92.7 to 85.3, mimalloc 135.7 to
130.4, the counts and drops 306.8 to 300.0; rt_construct 677,653 to
410,681 calls, rt_pair_record 176,261, rt_split_pair 23,596,
rt_drop_at 683,178 to 617,399, Composite::free 1,084,633 to 991,989
(the nested ones counted), mi_malloc 2,180,274 to 2,087,608; AT1's
synchronous row -0.4% (-0.9% by the estimate). With (B), the pair past
the test: the check row 2,370.7 to 2,301.9 (-2.9%), the parse row 974.3
to 941.6 (-3.4%), the compile row 3,934.1 to 3,834.3 (-2.5%); the
ratios by instructions against the reference's rows (441.6, 284.7 and
365.6) 5.21, 3.31 and 10.49 against the gate's 3 (5.37, 3.42 and 10.76
after AW8); the Rust front end's own rows within 0.2% of stage 2a's
(check 173.2, parse --json 246.7, compile 446.3). The functions
on the check row with (B): rt_construct 677,653 to 410,681 calls
(71.8 million inclusive), rt_pair_record 67,670 (6.7),
rt_split_pair 23,596 (5.5), rt_drop_at 683,178 to 529,303 (152.9),
Composite::free 1,084,633 to 650,434, mi_malloc 2,180,274 to
1,978,953. The check row by category, AW8's table against this one, in
millions: the records 79.9 to 57.6, the generated code 980.4 to 982.2,
the helpers' glue 92.7 to 85.3, mimalloc 135.7 to 121.1, the counts and
drops 306.8 to 279.3, the texts and copies 112.7 to 109.0, the natives
366.9 to 365.0, the hashing 55.6 to 55.6, the calls through the VM's
path 7.4 to 6.9, the comparisons 123.8 to 123.8, the load 46.2 to 46.5,
the iterators 40.3 to 40.3. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, stage 2a's binary against this
one): the synchronous JIT row 5,802.0 to 5,775.8 million instructions
(-0.5%) and 8,356.3 to 8,299.5 by the estimate (-0.7%), the image row
4,140.7 to 3,989.5 (-3.7%) and 6,084.3 to 5,846.3 by the estimate
(-3.9%), the cached run 4,220.6 to 4,069.4 (-3.6%), the interpreter
11,229.0 to 11,229.7 (+0.0%); the image 9,137,440 to 9,554,000 bytes
(+4.6%). The four benchmarks and hello by user-space instructions
(perf stat, the JIT synchronous, in millions): primes 265.0 to
265.0 (unchanged), strings 432.5 to 432.5 (unchanged), records
207.0 to 207.0 (unchanged), json_round_trip 839.7 to 839.7
(unchanged), hello 5.42 to 5.43 (+0.2%). The four judges byte-equal,
the conformance suite 55 of 55 on both tiers, the template tier's own
tests with the tier forced, 398 tests. Since stage 0 the check row
2,889.9 to 2,301.9 (-20.3%), since the study's binary 3,085.3 (-25.4%).
A candidate seen on the way, not decided: rt_resume_range refuses a
finished range iterator, so a function with two loops in sequence is
never entered at the second header from the interpreter. Next in AW1's
order: stage 2c, the frees in place.
AW10. Stage 2c of the new backend: the frees in place. The third
item of stage 2 in AW1's order (the study's item (2c)), on 2026-10-12,
measured as AW1 prescribes against stage 2b's binary (e87f3e1). The
last holder of a record freed its block through Rust's drop glue:
Composite::free dropped the fields as a slice, a call of the glue of
Value per field, which matched the tag through a jump table and, for
most fields, did nothing; a list's last holder did the same for its
elements through the drop of Rc<Vec<Value>>; rt_drop_at, which the
generated code calls for the last reference it releases in place, and
the stack's truncate went through the glue for the value itself. The
glue was called 11,647,789 times on the check row, 123.5 million
instructions self, from Rc<Vec<Value>>'s drop (3,805,425 of the
calls), Composite::free (2,272,022), rt_compare (1,225,584),
call_pure_from_stack (795,618), Vm::binary (559,604), rt_drop_at
(529,303), rt_iter_init (477,068), rt_call_typed (423,641) and the
rest. The checker's run on bodies.ry, instrumented for the day: of
the 3,203,871 fields the records' frees dropped, 708,069 were plain
values and 907,772 small Integers (a tag test's worth each), 1,151,018
counted blocks with another holder (a count to lower: 625,807 lists,
316,473 records, 199,026 variants) and 437,012 the last holder's
(202,092 records, 159,088 variants, 70,614 lists, 4,199 texts); of the
3,393,831 elements of the 82,713 lists the VM's own sites freed,
990,692 were plain, 2,197,214 shared blocks (2,189,471 of them records:
the checker's lists of bindings, copied when appended) and 192,294 the
last holder's. The study had the walk in the generated code; it is in
the VM's Rust, release_in_place in value.rs, one loop for every
site and no code grown, with the generated code's cost per value (its
release in place, decision AU32): a tag test for a plain value, the
count lowered in place for a shared block, and only the last holder
going further: of a record or a variant to Composite::free_block,
which releases the fields the same way and frees the block; of a list
to its elements released the same way and the vector freed empty; of
anything else, and a big Integer, to drop_in_place, the general way.
The first word of an Rc allocation is its strong count, which the
generated code's release relies on already, and the VM takes no weak
references. Built twice: the first build had one function out of line
for every value, and its prologue, paid by every plain field and
element, cost the check row 3.4% more than the glue (2,380.7 million);
the second inlines the fast path at every site (#[inline(always)]:
the tag test, the small Integer, the count lowered) and keeps the last
holder's work out of line (release_last), as the generated code's
release does. rt_drop_at and Pinned::truncate_values go through it,
so the generated code of both tiers and every frame's leave do; the
interpreter's other drops and the natives' stay Rust's, the glue's
remaining calls being stage 3's (the natives' entry and the glue). No
test is added: every program frees its values, and the corpus, the
conformance suite on both tiers, the sandbox's memory budget (the frees
go through the counting allocator as before) and the four judges hold
the change. What the measure found: by instructions the walk costs
nearly what the glue cost. The check row 2,301.9 to 2,296.2 million
(-0.2%) against the study's estimate of 3.2%: the glue's calls
11,647,789 to 6,030,437, but the counts and drops category 279.3 to
219.1 while the VM's own, where the table puts value.rs, 28.6 to
83.0, the two together 307.9 to 302.1 (-1.9%, the row's whole fall);
rt_drop_at 529,303 calls, 152.9 million inclusive to 148.4. The
frees' cost is the inspection of every field and element and the
deallocation, which no walk removes, not the glue's dispatch, which the
study had taken for it. What the walk does remove is the glue's
indirect branch per field: on the frozen self-check the synchronous JIT
row's indirect branches 17.3 million to 13.3 (-23.4%), its
mispredictions 32.5 to 32.4, and the row's estimate 8,299.5 to 8,192.5
million (-1.3%) on -0.4% by instructions; the stage stays by AT1's rule
(the estimate falls) and by the owner's rule for a marginal stage (the
check row within 0.5%, the estimate down). The measure in full
(callgrind under WSL on the release build for Linux, the images built
under valgrind --tool=none, against stage 2b's binary measured the
same way in AW9, the reference AU34's 44782aa): the check row 2,301.9
to 2,296.2 million instructions (-0.2%), the parse row 941.6 to 939.5
(-0.2%), the compile row 3,834.3 to 3,809.2 (-0.7%); the ratios by
instructions against the reference's rows (441.6, 284.7 and 365.6)
5.20, 3.30 and 10.42 against the gate's 3 (5.21, 3.31 and 10.49 after
AW9); the Rust front end's own rows within 0.2% of stage 2b's (check
173.5, parse --json 246.7, compile 446.2). The functions on the
check row: the glue of Value 11,647,789 to 6,030,437 calls (123.5 to
62.6 million self), release_last 928,387 calls,
Composite::free_block 650,434 (153.6 million inclusive, against
Composite::free's 650,434 calls before), Rc<Vec<Value>>'s drop
201,340 calls as before but calling the glue 3,805,425 to 886,989 times
(the vector empty when its last holder released it in place),
rt_drop_at 529,303 calls (148.4 million inclusive), mi_malloc
1,978,953 to 1,978,953, mi_free 1,777,179 to 1,777,179. The check row
by category, AW9's table against this one, in millions: the counts and
drops 279.3 to 219.1 and the VM's own 28.6 to 83.0, the records 57.6 to
57.6, the generated code 982.2 to 982.2, the helpers' glue 85.3 to
85.3, mimalloc 121.1 to 121.1, the texts and copies 109.0 to 109.0, the
natives 365.0 to 365.0, the hashing 55.6 to 55.6, the calls through the
VM's path 6.9 to 6.9, the comparisons 123.8 to 123.8, the load 46.5 to
46.5, the iterators 40.3 to 40.3. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, stage 2b's binary against this
one): the synchronous JIT row 5,775.8 to 5,750.6 million instructions
(-0.4%) and 8,299.5 to 8,192.5 by the estimate (-1.3%), its indirect
branches 17.3 to 13.3 million (-23.4%) and its mispredictions 32.5 to
32.4, the image row 3,989.5 to 3,972.3 (-0.4%) and 5,846.3 to 5,773.1
by the estimate (-1.3%), the cached run 4,069.4 to 4,052.1 (-0.4%), the
interpreter 11,229.7 to 11,181.9 (-0.4%); the image 9,554,000 to
9,554,000 bytes (unchanged: no generated code changed). The four
benchmarks and hello by user-space instructions (perf stat, the JIT
synchronous, in millions): primes 265.0 to 265.0 (unchanged),
strings 432.5 to 431.9 (-0.1%), records 207.0 to 204.2 (-1.4%),
json_round_trip 839.7 to 841.6 (+0.2%), hello 5.43 to 5.43
(unchanged). The four judges byte-equal, the conformance suite 55 of 55
on both tiers, the template tier's own tests with the tier forced, 398
tests. Since stage 0 the check row 2,889.9 to 2,296.2 (-20.5%), since
the study's binary 3,085.3 (-25.6%); stage 2 in all, 2,527.2 to
2,296.2. Next in AW1's order: stage 3, the natives' entry and the glue,
where the glue's remaining 6,030,437 calls are.
AW11. Stage 3a of the new backend: the natives' in-place entry. The
first item of stage 3 in AW1's order (the study's item (3a); its items
(3b) and (3c), the character tables and the hasher, are AW7), on
2026-10-12, measured as AW1 prescribes against stage 2c's binary
(f48282f). A pure native was called two ways from the generated code.
Through rt_call_typed when it carried a typed entry (decision AU1):
the helper looked the entry up, matched its kind, called it on the
arguments where they lay, wrote a scalar to the out slot or pushed a
value through typed_value_answer, consumed the arguments by the mask
and tested the memory budget, 42.0 million instructions self on 527,824
calls of the check row beside the entries' own work, and 19.0 million
more on the 239,842 values answered. Through rt_call_pure otherwise:
call_pure_from_stack drained the arguments into the scratch vector,
ran the native on them through run_native and answered through
Result and status, 47.2 million self on 341,454 calls (append
187,030, slice 94,734, with_at 22,718, quotient 13,677,
append_all 12,847) with a copy of the arguments, the vector's drop
glue and the glue of Value on every argument (795,618 of the glue's
6,030,437 calls) beside, and status 53.3 million on 1,567,934 calls
from every helper that answers a value. The two contains went through
AU34's lean helpers. The study's item (3a) prescribed a second entry
per native answering in place, and the owner chose it through AK1's
registration API over lean helpers for the hot ones only (AW1, answer
6). InPlace in extension.rs is that entry. in_place!(Int:
list_length_typed) makes one from a typed entry, for the four kinds,
and in_place!(takes list_append_in_place) from a function fn(&mut
[Value], u32) -> Option<Value> that takes its arguments
(take_or_clone of natives), given the mask of those the caller
still holds, which it copies rather than updates. The macro writes an
extern "C" shim, fn(vm, at, count, borrowed, pc) -> status, which
reads or takes the arguments where they lie on the stack, releases the
ones the call owns (a taken one is Nothing there, a tag test), writes
the answer over the first and answers CONTINUE, FAILURE for a
failure value, INTERRUPT with the interrupt parked, or DECLINED
with nothing touched. Native::with_in_place registers it, the
registry holds it to the declaration as it holds a typed entry (no
needs), and the VM keeps the shims in a table per function
(NativeState::in_place), which the generated code of both tiers calls
directly on one to thirty-two arguments: the Cranelift tier in
call_in_place (the shim's address loaded from the table and called
indirectly, a scalar answer read from the boxed value in place, the
typed call as the fallback when the entry declines), the template tier
in its call_in_place with the arguments in the convention's
registers, and the interpreter in Vm::call_in_place before the typed
entry. A moved operand of an entry that takes is the call's to consume,
so that append on a list the call owns pushes in place as the flat
path did, where a typed call lends it (decision AU17): taking_entry
in the borrow analysis. The standard library registers 26 entries:
quotient, at_least and at_most of Integer; length, is_empty,
contains, starts_with and ends_with of Text; length,
is_empty, first, last, with_at, slice, append,
append_all, contains, run_of, run_until, join and sum of
List; length, get and contains_key of Map; length and
contains of Set (with_at, append and append_all take; slice
and quotient through the read-only entries list_slice_typed and
integer_quotient_typed, written for the stage). List.at keeps
AU34's read in place with the typed call as its fallback, and AU34's
lean helpers rt_text_contains and rt_list_contains go, the entries
having taken their place (code format 20). Built twice. The first build
gave every entry one shape: a guard tested, the arguments released by a
loop over them, the memory budget tested after every answer, and in the
generated code the length stored twice and the status tested twice
(answered, then declined or failed). The check row fell 3.9% (2,296.2
to 2,207.4 million), but the strings benchmark, whose digits loop
calls Text.contains 1,188,895 times, rose 12.2% (431.9 to 484.6
million): the shims cost 93.3 million self on its 1,288,897 calls
against the lean helper's 23.8 million on its 1,188,895, 72
instructions a call against 20, and the generated code (every chunk of
the arena) 109.8 to 121.1 million. The second build gives a scalar
entry that reads its operands the lean helper's shape, which the
owner's choice did not ask it to give up: no guard tested (a typed
entry answers on plain values alone, a guarded value matching no plain
pattern, which rt_call_typed relies on too), no budget tested (a
scalar answer retains nothing and the arguments released only lower the
memory in use; the budget is tested at the next helper that allocates,
as the lean helpers had it), the arguments the call owns released by a
loop over the bits set (release_owned, one test when there are none),
and in the generated code one test of the status after the call with
the length stored for the answer alone; an entry that answers a value
or takes its operands keeps the failure test and the budget, and the
generated code tests its status as before (Entry::Takes tells the
tiers). The tests: tests/extension.rs registers an in-place entry
from twice's typed entry and a taking one on a new native grow,
which grows a list the call owns in place to a thousand items on both
tiers and copies one the caller keeps, and the check refuses an
in-place entry on a function with needs; the corpus, the conformance
suite on both tiers and the four judges hold the standard library's
entries. A correction to AW10 on the way: its self counts of the glue
of Value, 123.5 to 62.6 million, were summed over the annotator's
whole listing, whose source listings repeat the table's counts and add
the callee lines; over the function table alone they are 111.8 to 50.8
million (the calls as AW10 states them), and every self count here is
summed that way. What the measure found: the check row 2,296.2 to
2,203.9 million (-4.0%); the shims 1,050,545 calls, 133.2 million self
with the entries' bodies inlined into them (list_append,
list_slice, list_length_typed and the rest no longer appear as
functions; list_join_typed 97,732 calls and map_get_typed 121,757
do); on strings the shims 68.0 million self on 1,288,897 calls (53
instructions a call) and the generated code 115.9 million, the
benchmark +5.0% against stage 2c's lean helper: what remains over the
helper's 20 is the uniform call of five arguments, the shim's prologue,
which keeps the operands across the entry's call, and the answer boxed
and read back, which a scalar shim of two arguments with the entry
inlined would recover, an item for a later stage of the round;
records -17.4%, its lists appended in place through the taking entry.
The measure in full (callgrind under WSL on the release build for
Linux, the images built under valgrind --tool=none, against stage
2c's binary measured the same way in AW10, the reference AU34's
44782aa): the check row 2,296.2 to 2,203.9 million instructions
(-4.0%), the parse row 939.5 to 905.1 (-3.7%), the compile row 3,809.2
to 3,672.4 (-3.6%); the ratios by instructions against the reference's
rows (441.6, 284.7 and 365.6) 4.99, 3.18 and 10.04 against the gate's 3
(5.20, 3.30 and 10.42 after AW10); the Rust front end's own rows within
0.1% of stage 2c's (check 173.3, parse --json 246.7, compile
446.6). The functions on the check row: the shims 1,050,545 calls,
133.2 million self; rt_call_typed 527,824 to 1,908 calls (42.0 to 0.1
million self), typed_value_answer 239,842 to 1,896 (19.0 to 0.1),
rt_call_pure 341,454 to 10,448, call_pure_from_stack 341,454 to
10,448 (47.2 to 1.3), status 1,567,934 to 1,236,928 (53.3 to 42.1),
into_plain 816,882 to 816,882 (27.0 to 27.0), the glue of Value
6,030,437 to 3,933,657 (50.8 to 33.3), mi_malloc 1,978,953 to
1,978,955, mi_free 1,777,179 to 1,777,181; list_append 187,030 to 0
calls, list_slice 94,734 to 0 (both inlined into their shims now),
map_get_typed 121,757 to 121,757, list_join_typed 97,732 to 97,732
(list_length_typed, 76,950 calls before, and text_contains_typed,
154,702, are inlined into their shims). The check row by category,
AW10's table against this one, in millions: the natives 365.0 to 307.3,
the helpers' glue 85.3 to 74.0, the counts and drops 219.1 to 190.2,
the VM's own 83.0 to 89.6, the records 57.6 to 57.6, the generated code
982.2 to 986.4, mimalloc 121.1 to 121.0, the texts and copies 109.0 to
103.8, the hashing 55.6 to 55.8, the calls through the VM's path 6.9 to
6.9, the comparisons 123.8 to 123.8, the load 46.5 to 46.4, the
iterators 40.3 to 40.3. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, stage 2c's binary against this
one): the synchronous JIT row 5,750.6 to 5,613.6 million instructions
(-2.4%) and 8,192.5 to 8,019.3 by the estimate (-2.1%), its indirect
branches 13.3 to 12.7 million (-4.3%) and its mispredictions 32.4 to
31.9, the image row 3,972.3 to 3,828.9 (-3.6%) and 5,773.1 to 5,617.0
by the estimate (-2.7%), the cached run 4,052.1 to 3,908.7 (-3.5%), the
interpreter 11,181.9 to 11,098.7 (-0.7%); the image 9,554,000 to
9,601,808 bytes (+0.5%). The four benchmarks and hello by user-space
instructions (perf stat, the JIT synchronous, in millions): primes
265.0 to 265.2 (+0.1%), strings 431.9 to 453.7 (+5.0%), records
204.2 to 168.7 (-17.4%), json_round_trip 841.6 to 841.2 (within
0.05%), hello 5.43 to 5.44 (+0.2%). The four judges byte-equal, the
conformance suite 55 of 55 on both tiers, the template tier's own tests
with the tier forced, 399 tests. Since stage 0 the check row 2,889.9 to
2,203.9 (-23.7%), since the study's binary 3,085.3 (-28.6%). Next in
AW1's order: stage 3b, status and into_plain off the path (the
study's item (3d)), then stage 4.
AW12. Stage 3b of the new backend: status and into_plain off the
path. The last item of stage 3 in AW1's order, on 2026-10-12,
measured as AW1 prescribes against stage 3a's binary (9828e2e). Every
helper that answered a value went through status: a Result built
and matched, the value pushed and tested for a failure, 1,236,928 calls
on the check row after AW11 (42.1 million instructions self), from
rt_construct (410,681 calls, 34.1 million self),
rt_construct_variant (280,398, 23.3), rt_compare's general path
(279,802 calls through status, of the helper's 521,364),
rt_list_push (158,109, with op_list_push 15.6 million) and the
rest. And every value that might carry a guard went through
into_plain out of line, 816,882 calls (27.0 million), from
op_list_push (twice per push), iterate and iterator_of (once each
per loop), and through guarded (263,285 calls, 5.0 million), where
nearly every value is plain and nearly every origin is none: a call, a
match and a move each, for a test of one byte. The stage takes the glue
off the path where the answer cannot fail or the value is plain. (1)
Value::into_plain and Value::guarded test in place and keep the
unwrapping and the wrapping out of line (unguarded, with_origins),
and origins and plain are inlined. (2) A Construct of a plain
record type (a record without a refinement to check, not the date,
whose construction validates: plain_record_type) and a
ConstructVariant with fields of a type without refinements
(plain_variant_type) cannot fail, so both tiers call
rt_construct_plain and rt_construct_variant_plain, which build the
value in place of its fields and push it, with no Result, no status
to test and no pc; under a provenance guard they lift the fields'
origins onto the value as the general helpers do; the interpreter's own
path and the general helpers are unchanged. (3) rt_list_push pushes a
plain item onto a plain list where the list lies, one tag test each,
with no unwrapping, no origins and no Result between; a guarded value
or a holder that is no list goes through op_list_push as before. (4)
rt_compare's general path pushes its boxed answer itself. (5)
iterator_of takes a plain list as it is, with no origins, no
unwrapping, no special and no listing. Code format 21 (two helpers
more). The tests: the corpus, the conformance suite on both tiers, the
four judges and tests/guards.rs (the guarded paths of the helpers)
hold the stage, with a new test in tests/native.rs,
plain_builders_lift_the_origins_of_guarded_fields_as_the_general_helpers_do,
which runs a guarded program (records and variants with fields built
from the secret, collected lists, loops over a guarded list and a plain
one) on machine code against the interpreter. What the measure found:
the check row 2,203.9 to 2,099.1 million (-4.8%); status 1,236,928 to
108,008 calls (42.1 to 3.7 million self), into_plain 816,882 to 0
(27.0 to 0.0), guarded 263,285 to 0, rt_construct 410,681 to 28
with rt_construct_plain 410,653 (26.7 million self against
rt_construct's 34.1 before), rt_construct_variant 280,398 to 42
with rt_construct_variant_plain 280,356 (19.1 against 23.3),
rt_list_push 3.2 to 8.3 million self with op_list_push 158,109 to 0
calls, iterator_of 19.1 to 11.2 million with iterate 238,534 to 0
calls; the helper glue category 74.0 to 3.7 million, the records 57.6
to 46.0, the iterators 40.3 to 25.3, the comparisons 123.8 to 131.6,
the generated code 986.4 to 981.3. The measure in full (callgrind under
WSL on the release build for Linux, the images built under valgrind
--tool=none, against stage 3a's binary measured the same way in AW11,
the reference AU34's 44782aa): the check row 2,203.9 to 2,099.1 million
instructions (-4.8%), the parse row 905.1 to 878.7 (-2.9%), the compile
row 3,672.4 to 3,531.7 (-3.8%); the ratios by instructions against the
reference's rows (441.6, 284.7 and 365.6) 4.75, 3.09 and 9.66 against
the gate's 3 (4.99, 3.18 and 10.04 after AW11); the Rust front end's
own rows within 0.1% of stage 3a's (check 173.4, parse --json
246.7, compile 446.2). The functions on the check row: status
1,236,928 to 108,008 calls (42.1 to 3.7 million self), into_plain
816,882 to 0 (27.0 to 0.0; unguarded 0 calls), guarded 263,285 to 0
(5.0 to 0.0; with_origins 0), rt_construct 410,681 to 28 (71.8 to
0.0 million inclusive) and rt_construct_plain 410,653 (50.4
inclusive, 26.7 self), rt_construct_variant 280,398 to 42 (46.5 to
0.0) and rt_construct_variant_plain 280,356 (32.8 inclusive, 19.1
self), rt_list_push 158,109 to 158,109 (51.0 to 20.9 inclusive) with
op_list_push 158,109 to 0, rt_compare 521,364 to 521,364 (127.5 to
125.8 inclusive), rt_iter_init 74.1 to 43.3 inclusive with iterate
238,534 to 0 calls, the shims 1,050,545 calls (133.2 million self), the
glue of Value 3,933,657 to 3,775,548 (33.3 to 32.5), mi_malloc
1,978,955 to 1,978,955, mi_free 1,777,181 to 1,777,181. The check row
by category, AW11's table against this one, in millions: the natives
307.3 to 297.2, the helpers' glue 74.0 to 3.7, the counts and drops
190.2 to 189.4, the VM's own 89.6 to 90.0, the records 57.6 to 46.0,
the generated code 986.4 to 981.3, mimalloc 121.0 to 121.1, the texts
and copies 103.8 to 103.8, the hashing 55.8 to 55.7, the calls through
the VM's path 6.9 to 6.9, the comparisons 123.8 to 131.6, the load 46.4
to 46.4, the iterators 40.3 to 25.3. AT1's rows on the frozen
self-check (tools/measure_size.sh under WSL, stage 3a's binary
against this one): the synchronous JIT row 5,613.6 to 5,456.5 million
instructions (-2.8%) and 8,019.3 to 7,800.2 by the estimate (-2.7%),
its indirect branches 12.7 to 11.9 million (-6.6%) and its
mispredictions 31.9 to 31.9, the image row 3,828.9 to 3,694.0 (-3.5%)
and 5,617.0 to 5,486.6 by the estimate (-2.3%), the cached run 3,908.7
to 3,774.1 (-3.4%), the interpreter 11,098.7 to 11,204.0 (+0.9%, the interpreter's own
paths with the tests inlined, not measured further: the tiers' rows
are AT1's measure); the
image 9,601,808 to 9,567,648 bytes (-0.4%). The four benchmarks and
hello by user-space instructions (perf stat, the JIT synchronous, in
millions): primes 265.2 to 265.2 (unchanged), strings 453.7 to
450.7 (-0.7%), records 168.7 to 157.1 (-6.9%), json_round_trip
841.2 to 841.1 (within 0.05%), hello 5.44 to 5.44 (unchanged). The
four judges byte-equal, the conformance suite 55 of 55 on both tiers,
the template tier's own tests with the tier forced, 400 tests. Since
stage 0 the check row 2,889.9 to 2,099.1 (-27.4%), since the study's
binary 3,085.3 (-32.0%); stage 3 in all, 2,296.2 to 2,099.1. Next in
AW1's order: stage 4, two values of a field-less variant type compared
in place, match by a table, the iterator in two slots.
AW13. Stage 4a of the new backend: is and is not answered in
place, and two values of a variant type compared in the generated
code. The first item of stage 4 in AW1's order, on 2026-10-12,
measured as AW1 prescribes against stage 3b's binary (1b25b85). The
check row's 521,364 comparisons went through rt_compare (66.8 million
instructions self, 125.8 inclusive), whose fast path answered small
Integers, texts, Booleans, Nothing beside a value and two variants
without fields of a type without its own equals (199,851 calls of
has_declared_equals), and whose general path took every other is
and is not (309,995 calls of binary_values, 30,193 of them
rt_binary's): the operands popped, binary_values's own fast arms
tried again, binary (9.1 million self), equal (10.6) and at last
Value::eq (23.1 million self over 644,592 calls, 279,802 of them from
equal, the rest the natives' and the hashed lookups'), the Boolean
boxed, pushed and unboxed by the generated code: about 250 instructions
around an equality of about 35. The stage: (1) compare_in_place
answers is and is not on any operands as structural equality,
Value::eq on the plain values, unless the left operand's type
declares its own equals, which the general path keeps running
(has_declared_equals inlined); an ordering is still answered for two
small Integers, texts or Booleans and takes the general path otherwise.
(2) The generated code of both tiers compares two values the checker
typed as one variant type without its own equals and with at most 64
variants (sum_compared in native/infer.rs, which also gives the
tags that name a variant with fields, one bit per tag) in place: when
both lie as variants (a guarded value does not, and takes the helper),
the type and the tag their blocks hold are compared; different ones
answer, and the same tag answers when it names a variant without fields
and goes to the helper otherwise, which compares the fields, with the
operands untouched; the answer goes to its register (on the template
tier to the out slot, then boxed where the left operand lay), and the
operands not borrowed (AU13's masks) are released in place
(compare_sum_variants in native/codegen.rs and in
native/template/mod.rs, beside AU26's small texts and AU45's small
Integers; the template assembler gained the 64-bit bt). The first
build compared only the types none of whose variants has a field, and
its measure found that path taken by 238 of the check row's
comparisons: the checker compares Ty and TokenKind values, and both
types have variants with fields beside the field-less ones it mostly
compares; the second build is the one measured. The tests: the corpus,
the conformance suite on both tiers, the four judges, AU13's comparison
test and a new one in tests/native.rs and tests/template.rs,
variants_compare_in_place_by_tag_and_fielded_ones_through_the_helper,
which runs field-less variants in both orders and with both operators,
different tags and the same tag of a type with fielded variants, the
same tag with fields, a guarded one read out of a guarded record, a
maybe, a type with its own equals and lists on machine code against
the interpreter. What the measure found: the check row 2,099.1 to
1,995.8 million (-4.9%); rt_compare 521,364 to 43,402 calls (66.8 to
3.5 million self, 125.8 to 5.1 inclusive), binary_values 309,995 to
30,193 (12.3 to 1.6), binary 279,802 to 0 (9.1 to 0.0), equal
279,802 to 0 (10.6 to 0.0), has_declared_equals 199,851 to 0
(inlined), Value::eq 644,592 to 414,005 (23.1 to 15.4); the
comparisons category 131.6 to 34.5 million, the hashing and equality
55.7 to 48.3, the counts and drops 189.4 to 173.8, the generated code
981.3 to 998.0. The measure in full (callgrind under WSL on the release
build for Linux, the images built under valgrind --tool=none, against
stage 3b's binary measured the same way in AW12, the reference AU34's
44782aa): the check row 2,099.1 to 1,995.8 million instructions
(-4.9%), the parse row 878.7 to 827.8 (-5.8%), the compile row 3,531.7
to 3,260.6 (-7.7%); the ratios by instructions against the reference's
rows (441.6, 284.7 and 365.6) 4.52, 2.91 and 8.92 against the gate's 3
(4.75, 3.09 and 9.66 after AW12); the Rust front end's own rows within
0.1% of stage 3b's (check 173.5, parse --json 246.7, compile
446.4). The functions on the check row: rt_compare 521,364 to 43,402
calls (66.8 to 3.5 million self, 125.8 to 5.1 inclusive),
has_declared_equals 199,851 calls (3.4 million self) to none of its
own, inlined, binary_values 309,995 to 30,193 (48.8 to 2.3
inclusive), binary 279,802 to 0 (9.1 to 0.0 self), equal 279,802 to
0 (20.1 to none inclusive), Value::eq 644,592 to 414,005 (23.1 to
15.4 self), Vm::compare (the sort's) 366,276 to 366,276 (17.6 to
17.6), rt_binary 30,193 to 30,193, the shims 1,050,545 calls (133.2
million self), the glue of Value 3,775,548 to 2,016,576 (32.5 to
17.0), mi_malloc 1,978,955 to 1,978,955, mi_free 1,777,181 to
1,777,181. The check row by category, AW12's table against this one, in
millions: the comparisons 131.6 to 34.5, the hashing and equality 55.7
to 48.3, the counts and drops 189.4 to 173.8, the generated code 981.3
to 998.0, the natives 297.2 to 297.2, the VM's own 90.0 to 90.0, the
records 46.0 to 46.0, mimalloc 121.1 to 121.1, the texts and copies
103.8 to 103.8, the calls through the VM's path 6.9 to 6.9, the
helpers' glue 3.7 to 3.7, the load 46.4 to 46.4, the iterators 25.3 to
25.3. AT1's rows on the frozen self-check (tools/measure_size.sh
under WSL, stage 3b's binary against this one): the synchronous JIT row
5,456.5 to 5,248.2 million instructions (-3.8%) and 7,800.2 to 7,546.0
by the estimate (-3.3%), its indirect branches 11.9 to 10.7 million
(-9.5%) and its mispredictions 31.9 to 31.2, the image row 3,694.0 to
3,473.0 (-6.0%) and 5,486.6 to 5,166.3 by the estimate (-5.8%), the
cached run 3,774.1 to 3,552.7 (-5.9%), the interpreter 11,204.0 to
11,203.6 (within 0.05%); the image 9,567,648 to 9,588,256 bytes
(+0.2%). The four benchmarks and hello by user-space instructions
(perf stat, the JIT synchronous, in millions): primes 265.2 to
265.2 (unchanged), strings 450.7 to 450.7 (unchanged), records
157.1 to 157.1 (unchanged), json_round_trip 841.1 to 841.1
(unchanged), hello 5.44 to 5.44 (unchanged). The four judges
byte-equal, the conformance suite 55 of 55 on both tiers, the template
tier's own tests with the tier forced, 402 tests. Since stage 0 the
check row 2,889.9 to 1,995.8 (-30.9%), since the study's binary 3,085.3
(-35.3%). Next in AW1's order: the rest of stage 4, the iterator in two
slots (4b) and match by a table (4c).
AW14. Stage 4b of the new backend: a loop's iterator in two slots of
the frame. The second item of stage 4 in AW1's order (the owner's
answer 8 there: the iterator in two slots as a bytecode change in both
emitters with the judges), on 2026-10-12, measured as AW1 prescribes
against stage 4a's binary (cf06592). A for each over anything but a
range held in registers allocated a native iterator (Native::Iterator
with a ListIter: the items' address, their count, the position and
the list, in a counted block): 238,534 on the check row through
rt_iter_init (43.3 million instructions inclusive, iterator_of 11.2
self), freed when the frame left (238,534 drops of the native, 6.5
million self, 33.8 inclusive with the block's free), and the generated
code read the position through the slot, the block and the native every
turn and wrote it back. The stage: (1) both emitters allocate two
consecutive slots per loop (loop_slots in compile/mod.rs and in
compiler/emit.ry, at every IterInit: the plain loop, the two passes
of a sorted one, a query's sources and its sorted pass, the compile
judge holding them equal): the first holds the source listed (the list
itself; the items of a set, a map, a text or a guarded source as a
list; a range of small Integers as its own iterator value, as before),
the second the position as a small Integer. (2) The interpreter's
IterInit writes both and IterNext reads the item at the position
and advances it (iterator_of, iterator_next); the helpers
rt_iter_init and rt_iter_next do the same, and the template tier
calls them as before. (3) The analysis marks the second slot an Integer
(SlotKind::Int), so the Cranelift tier keeps the position in a
register: IterInit moves a plain list from the stack into the slot
where it lies, the slot's old value released, and sets the register to
0 (anything else through the helper, which lists it; a range in
registers sets the register too); IterNext tests the slot for a list,
reads the items' address and their count through the list's block as
List.at does (AU34: the layout words from the native state), compares
the position, copies the item with one more reference and advances the
register; a range iterator value in the slot takes the helper as
before; a hand-back boxes the position as any Integer slot (rt_deopt)
and an entry at a loop header reads it back (rt_resume_int), so a
loop goes on in the interpreter from where the code was and comes back.
(4) The bytecode file is format 9 and the image format 22 (the slots);
Native::Iterator, ListIter and the layout constants of the native
iterator are gone. The tests: the corpus, the conformance suite on both
tiers, the four judges (the compile judge on the slots of every loop of
the corpus, the suite and compiler/), the loop tests of
tests/native.rs and tests/template.rs, and a new one in both,
loops_in_two_slots_keep_their_list_and_position_across_a_hand_back: a
product that leaves the machine word inside a loop hands the frame back
and the loop goes on in the interpreter, the list grown in its own body
keeps the loop's items, an inner loop uses its slots again on every
row, a sorted loop and a query over two sources run, on machine code
against the interpreter. What the measure found on the check row:
rt_iter_init 238,534 to 0 calls (43.3 million inclusive to none:
every loop's source there is a plain list, placed by the generated
code), iterator_of 238,534 to 0 (11.2 to 0.0 self), rt_iter_next
not called before either (the generated code read a list iterator in
place since AU34), the native's drops 238,534 to 0 (6.5 to 0.0 self),
mi_malloc 1,978,955 to 1,740,421, mi_free 1,777,181 to 1,538,721,
rt_truncate 97,106 to 97,106 (28.6 to 26.6 inclusive), the glue of
Value 2,016,576 to 1,191,936 (17.0 to 10.2). The measure in full
(callgrind under WSL on the release build for Linux, the images built
under valgrind --tool=none, against stage 4a's binary measured the
same way in AW13, the reference AU34's 44782aa): the check row 1,995.8
to 1,930.3 million instructions (-3.3%), the parse row 827.8 to 827.6
(within 0.05%), the compile row 3,260.6 to 3,156.9 (-3.2%); the ratios
by instructions against the reference's rows (441.6, 284.7 and 365.6)
4.37, 2.91 and 8.63 against the gate's 3 (4.52, 2.91 and 8.92 after
AW13); the Rust front end's own rows within 0.1% of stage 4a's (check
173.3, parse --json 246.7, compile 446.2). The check row by
category, AW13's table against this one, in millions: the iterators
25.3 to 0.0, the counts and drops 173.8 to 152.2, mimalloc 121.1 to
108.8, the generated code 998.0 to 1,000.9, the comparisons 34.5 to
34.5, the hashing and equality 48.3 to 47.4, the natives 297.2 to
297.2, the VM's own 90.0 to 88.9, the records 46.0 to 46.0, the texts
and copies 103.8 to 96.7, the calls through the VM's path 6.9 to 6.9,
the helpers' glue 3.7 to 3.7, the load 46.4 to 46.5. AT1's rows on the
frozen self-check (tools/measure_size.sh under WSL, stage 4a's binary
against this one): the synchronous JIT row 5,248.2 to 5,224.1 million
instructions (-0.5%) and 7,546.0 to 7,481.6 by the estimate (-0.9%),
its indirect branches 10.7 to 10.6 million (-1.5%) and its
mispredictions 31.2 to 31.7, the image row 3,473.0 to 3,401.3 (-2.1%)
and 5,166.3 to 5,103.8 by the estimate (-1.2%), the cached run 3,552.7
to 3,481.0 (-2.0%), the interpreter 11,203.6 to 11,217.7 (+0.1%); the
image 9,588,256 to 9,742,192 bytes (+1.6%). The four benchmarks and
hello by user-space instructions (perf stat, the JIT synchronous, in
millions): primes 265.2 to 265.9 (+0.3%), strings 450.7 to 442.9
(-1.7%), records 157.1 to 160.9 (+2.4%), json_round_trip 841.1 to
843.9 (+0.3%), hello 5.44 to 5.44 (unchanged). The four judges
byte-equal, the conformance suite 55 of 55 on both tiers, the template
tier's own tests with the tier forced, 403 tests. Since stage 0 the
check row 2,889.9 to 1,930.3 (-33.2%), since the study's binary 3,085.3
(-37.4%). Next in AW1's order: the last item of stage 4, match by a
table (4c), then the checker's own cuts between the stages, stages 5
and 6.
AW15. Stage 4c of the new backend: match by a table. The last
item of stage 4 in AW1's order, on 2026-10-12, measured as AW1
prescribes against stage 4b's binary (8eed964). A match tested its
arms in turn: for every arm whose pattern names a variant, the subject
loaded, its tag tested (IsVariant, in place since AU49) and a jump
past the arm when it did not fit, so that a value of the last of n
variants paid n tests, each a load, a test and a branch, and the
checker's and the parser's matches over the kinds of expressions, types
and tokens paid most of theirs on the arms before the right one. The
stage: (1) a new op, JumpByTag { slot, table }, with the jump tables
of a code object beside its ops (Code.tables): the op peeks at the
frame slot and, for a variant whose tag is below the table's length,
jumps to the table's entry for the tag; anything else, a guarded value,
a Nothing, a failure, a tag past the table, falls through to the
arms' own tests, which stay as they were. (2) Both emitters emit it
after the subject's store when at least three arms name a variant
(TABLE_ARMS in compile/expr.rs, the same number in
compiler/emit.ry), the table filled once the arms' positions are
known (match_table in both): for every tag up to the highest an arm
names, the first arm in order that can match it, entered past its own
tag test (three ops: the load, the test, the jump) when it names the
tag and at its start when its pattern is anything else (a binding, a
typed name, a literal, a some, a record matched like a single
variant: any of them may fit), else the otherwise or the crash after
the arms; a guard or a nested pattern that fails goes on down the arms
as before. The compile judge holds the two emitters equal on the tables
of every program of the corpus, the suite and compiler/. (3) The
interpreter reads the slot's plain value; the Cranelift tier reads the
slot's kind and the block's tag in place and enters the arm's block
through a jump table (br_table), the edges coerced as a branch's are,
the fall-through the block after; the template tier compares the tag
with each entry in turn (cmp, je), the entries block starts of its
counting. The analysis follows the table's targets among the flows
(native/infer.rs, both passes), as do the last reads (liveness.rs)
and the inliner, which appends an expanded callee's tables to the
caller's with the targets shifted. (4) The bytecode file is format 10,
the binary encoding 6 and the image format 23. The tests: the corpus,
the conformance suite on both tiers, the four judges, and a new test in
tests/native.rs and tests/template.rs,
matches_by_a_table_enter_the_arm_by_the_tag_and_fall_through_otherwise:
six arms with a guard that fails to a later arm of the same tag, a
nested literal that fails to the next arm, field-less arms, a tag past
the table, an overflow inside an arm entered through the table (the
frame handed back), a binding arm entered at its start, a maybe
subject and a two-arm match without a table, and a guarded subject that
falls through, on machine code against the interpreter. What the
measure found on the check row: the generated code 1,000.9 to 962.7
million, the comparisons 34.5 to 34.5, the counts and drops 152.2 to
152.2, the glue of Value 1,191,936 to 1,191,936 calls (10.2 to 10.2
million self), mi_malloc 1,740,421 to 1,740,842. The measure in full
(callgrind under WSL on the release build for Linux, the images built
under valgrind --tool=none, against stage 4b's binary measured the
same way in AW14, the reference AU34's 44782aa): the check row 1,930.3
to 1,896.4 million instructions (-1.8%), the parse row 827.6 to 822.8
(-0.6%), the compile row 3,156.9 to 3,097.6 (-1.9%); the ratios by
instructions against the reference's rows (441.6, 284.7 and 365.6)
4.29, 2.89 and 8.47 against the gate's 3 (4.37, 2.91 and 8.63 after
AW14); the Rust front end's own rows within 0.2% of stage 4b's (check
173.1, parse --json 246.7, compile 447.2). The check row by
category, AW14's table against this one, in millions: the generated
code 1,000.9 to 962.7, the comparisons 34.5 to 34.5, the counts and
drops 152.2 to 152.2, mimalloc 108.8 to 108.7, the hashing and equality
47.4 to 47.7, the natives 297.2 to 297.2, the VM's own 88.9 to 88.9,
the records 46.0 to 46.0, the texts and copies 96.7 to 96.8, the calls
through the VM's path 6.9 to 6.9, the helpers' glue 3.7 to 3.7, the
load 46.5 to 50.4, the iterators 0.0 to 0.0. AT1's rows on the frozen
self-check (tools/measure_size.sh under WSL, stage 4b's binary
against this one): the synchronous JIT row 5,224.1 to 5,156.1 million
instructions (-1.3%) and 7,481.6 to 7,395.6 by the estimate (-1.1%),
its indirect branches 10.6 to 10.5 million (-0.7%) and its
mispredictions 31.7 to 30.4, the image row 3,401.3 to 3,371.1 (-0.9%)
and 5,103.8 to 4,998.4 by the estimate (-2.1%), the cached run 3,481.0
to 3,451.4 (-0.9%), the interpreter 11,217.7 to 11,061.4 (-1.4%); the
image 9,742,192 to 9,770,848 bytes (+0.3%). The four benchmarks and
hello by user-space instructions (perf stat, the JIT synchronous, in
millions): primes 265.9 to 265.9 (unchanged), strings 442.9 to
442.9 (unchanged), records 160.9 to 160.9 (unchanged),
json_round_trip 843.9 to 843.9 (unchanged), hello 5.44 to 5.44
(unchanged). The four judges byte-equal, the conformance suite 55 of 55
on both tiers, the template tier's own tests with the tier forced, 405
tests. Since stage 0 the check row 2,889.9 to 1,896.4 (-34.4%), since
the study's binary 3,085.3 (-38.5%). Stage 4 is done. Next in AW1's
order: the checker's own cuts between the stages, then stages 5 and 6.
AW16. The checker's own cuts between the stages: the variants indexed
by name, the parser's cursor with its token, the lexer's previous token
as two Integers and the text of a run as a primitive, the resolver's
loop, the lists updated in the slot. The item of AW1's order after
stage 4, on 2026-10-12, measured as AW1 prescribes against stage 4c's
binary (805ea3a). The cuts are in the compiler written in Renyi
(compiler/*.ry), one library primitive beside them; each was gated by
renyi check, the canonical layout and the four judges byte-equal,
then kept or dropped by the lane's quick measure, the check row by
perf stat (user-space instructions) with the images rebuilt from the
edited sources, 1,860.8 million before any cut. (1) The variants of a
module's scope indexed by name once the types are final
(index_variants and variants_of at the end of resolve_all, the
variants field of ModuleInfo, in compiler/declare.ry):
lookup_variant rebuilt its candidates (the module's types, the
exposed ones, the prelude's, distinct and sorted) and scanned every sum
type's variants on each of its 650 calls, 102.6 million instructions
inclusive, 5.4% of the row; it is one map read now. The row 1,860.8 to
1,766.6 (-5.1%). (2) The parser's cursor carries its looked-at token
(token in Cursor): at_position computes the look and the token
together (what look_from did) and binds them before the update, so
that the cursor is updated in its slot (AU11, AW8) where the update
read the cursor twice in one statement and copied it on every move
(rt_record_copy 124,609 calls); moved changes the position alone,
the look and the token at it being the same already; 39 sites read
cursor.token in place of token_at(cursor, look). 1,766.6 to 1,719.5
(-2.7%). (3) The lexer's previous token as two Integers, its stop and
its code (previous_stop and previous_code through lex_range,
next_step, lex_word, lex_text and camel_case_word), compared in
place against words.symbol_dot and words.word_raw where a maybe
Token was matched on at every word and every text literal; a reserved
word's text sliced once (lex_reserved takes the word's text) where it
was sliced three times; and the parser sets the comments aside in one
pass over the tokens where two queries ran. 1,719.5 to 1,628.7 (-5.3%).
(4) resolve follows a variable's binding in one match per step
(is_bound_var gone) where it looked the variable up twice per step.
1,628.7 to 1,615.8 (-0.8%). (5) The lexer's text of a run as a library
primitive, slice_text(self: List of Text, start: Integer, stop:
Integer) returns Text, a library addition through the sketch,
library/std/prelude.ry, the checker's copy and natives/prelude.rs
(a typed and an in-place entry; a test in tests/semantics.rs), as
AU52 (iv) added run_of: the texts from start to stop as one text, the
bounds clamped as slice clamps them, where slice then join
allocated a list, raised and lowered a count per character and
allocated the text (135.1 million inclusive for 94,725 slices, 7.1%);
the lexer's 19 slices, the parser's text_of and the checker's
source_text use it; the cheat sheet does not list it, its budget
standing at 2,997 of 3,000 tokens. 1,615.8 to 1,561.4 (-3.4%). (6) The
checker's scopes flattened into one list of bindings with the scope
starts measured worse (1,561.4 to 1,575.7, +0.9%: a pop truncates by
take, which copies) and was dropped; in its place the lists of scopes
and of inference variables are updated in the checker's slot,
checker.scopes.with_at(...) and checker.vars.with_at(...) in the
update, where lists.replace_at(items: checker.scopes, ...) read the
list out of the record (a second holder, which the native copied) on
every binding declared, marked as used or retagged and on every
variable bound. (7) The parser's bracket loop looks the closing
symbol's code up once, not per element, and zonk resolves a type
once. The row 1,561.4 to 1,554.3 (-0.5%) with (7), to 1,548.3 (-0.4%)
with (6). The sum by the quick measure: 1,860.8 to 1,548.3 million
(-16.8%). What the profile leaves (study_incl.py, the lane's new
script, ranks the generated functions by their inclusive cost, what a
cut in the Renyi sources removes): the record copies 124,609 to 109,613
only, since the parser's result records (Parsed, Peek, Eaten) are
read after their cursor is taken at 186 sites, which keeps the cursor
shared so that at_position copies it on most moves (AU55's rewrite
for Done applied to them is the next cut there); the clones 4,753,908
to 3,822,834, mimalloc's allocations 1,740,842 to 1,378,394, the lists
joined 97,732 to 3,011; and the backend's own costs, the call of a
five-op helper (is_word and is_symbol, 178,401 calls at 119
instructions each) and the clone a field read makes, which stages 5 and
6 and AU50's expansion are for. The measure in full (callgrind under
WSL on the release build for Linux, the images built under valgrind
--tool=none, against stage 4c's binary measured the same way in AW15,
the reference AU34's 44782aa): the check row 1,896.4 to 1,586.1 million
instructions (-16.4%), the parse row 822.8 to 711.9 (-13.5%), the
compile row 3,097.6 to 2,794.9 (-9.8%); the ratios by instructions
against the reference's rows (441.6, 284.7 and 365.6) 3.59, 2.50 and
7.64 against the gate's 3 (4.29, 2.89 and 8.47 after AW15); the Rust
front end's own rows within 0.6% of stage 4c's (check 173.8, parse
--json 246.4, compile 449.7). The check row by category, AW15's
table against this one, in millions: the generated code 962.7 to 800.8,
the comparisons 34.5 to 6.5, the counts and drops 152.2 to 131.6,
mimalloc 108.7 to 87.9, the hashing and equality 47.7 to 35.2, the
natives 297.2 to 255.8, the VM's own 88.9 to 79.5, the records 46.0 to
46.1, the texts and copies 96.8 to 79.5, the calls through the VM's
path 6.9 to 8.5, the helpers' glue 3.7 to 3.6, the load 50.4 to 50.4,
the iterators 0.0 to 0.0. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, stage 4c's binary against this one;
the tiers are the same, the one native added): the synchronous JIT row
5,156.1 to 5,160.2 million instructions (+0.1%) and 7,395.6 to 7,381.0
by the estimate (-0.2%), its indirect branches 10.5 to 10.5 million
(+0.1%) and its mispredictions 30.4 to 30.2, the image row 3,371.1 to
3,374.3 (+0.1%) and 4,998.4 to 5,043.5 by the estimate (+0.9%), the
cached run 3,451.4 to 3,464.0 (+0.4%), the interpreter 11,061.4 to
11,068.3 (+0.1%); the image 9,770,848 to 9,770,928 bytes (within
0.05%). The four benchmarks and hello by user-space instructions (perf
stat, the JIT synchronous, in millions): primes 265.9 to 266.0
(within 0.05%), strings 442.9 to 443.0 (within 0.05%), records
160.9 to 160.9 (unchanged), json_round_trip 843.9 to 843.9
(unchanged), hello 5.44 to 5.47 (+0.6%). The four judges byte-equal,
the conformance suite 55 of 55 on both tiers, 406 tests. Since stage 0
the check row 2,889.9 to 1,586.1 (-45.1%), since the study's binary
3,085.3 (-48.6%). Next in AW1's order: stages 5 and 6.
AW17. Stage 5a of the new backend: the moves of AU17 written in the
image and in the cache keyed by the sources. The first half of stage
5 of AW1's order (the load), on 2026-10-12, measured as AW1 prescribes
against the cuts' binary (c7b8f6c). AU17 ran its liveness pass on a
copy of the program before every run, so that the bytecode file, the
image's program and the cache's key stayed what the emitters wrote: on
the checker's image run the copy and the pass cost 37.5 million
instructions, 2.4% of the row (liveness::prepared inclusive in the
cuts' profile), at every run of a program whose machine code was
compiled from the prepared program already. Now the pass runs once,
where a program enters the VM, and marks it: Program::prepared, a
flag the binary encoding keeps (encoding 7, the flag after the format)
and the bytecode file does not (the .ryc stays the emitters' program,
held equal by the judges); liveness::prepare applies the moves in
place and sets the flag, and liveness::prepared answers the program
itself (Cow::Borrowed) when it is prepared and a prepared copy
otherwise, which the runner, the sandbox and image::build take.
renyi build writes the prepared program in the image, so that a run
from an image, a file's or the cache's, skips the pass; the binary's
compile_cached prepares the program on every path (an image's comes
prepared; a bytecode file's and a fresh compile's are prepared there)
and stores the prepared encoding in the cache keyed by the sources, so
that a run from that cache skips it too and the image cache's entry,
named from that encoding, holds the image's program byte for byte as
before. This reverses the part of AU17 that kept the image's program
and the cache's key as the emitters wrote them; the bytecode file keeps
that promise, and tests/build.rs now holds the image's program to the
bytecode file's prepared by the pass. An image built from a program
that comes prepared (build --cache) carries in code_hash the hash
of the prepared rendering, which nothing reads: a run through the cache
takes its hash from the sources, and build from a file prepares a
copy and hashes the file's program. A test in tests/native.rs holds
the pass to once: a prepared program is borrowed, a second pass over it
finds nothing, and the flag survives the encoding. The measure in full
(callgrind under WSL on the release build for Linux, the images built
under valgrind --tool=none, against the cuts' binary measured the
same way in AW16, the reference AU34's 44782aa): the check row 1,586.1
to 1,547.9 million instructions (-2.4%), the parse row 711.9 to 701.6
(-1.4%), the compile row 2,794.9 to 2,743.6 (-1.8%); the ratios by
instructions against the reference's rows (441.6, 284.7 and 365.6)
3.51, 2.46 and 7.50 against the gate's 3 (3.59, 2.50 and 7.64 after
AW16); the Rust front end's own rows within 0.1% of the cuts' (check
173.8, parse --json 246.4, compile 450.0). The check row by
category, AW16's table against this one, in millions: the load 50.4 to
26.1, the generated code 800.8 to 800.8, the comparisons 6.5 to 6.5,
the counts and drops 131.6 to 131.0, mimalloc 87.9 to 79.8, the hashing
and equality 35.2 to 35.4, the natives 255.8 to 255.8, the VM's own
79.5 to 79.5, the records 46.1 to 46.1, the texts and copies 79.5 to
74.4, the calls through the VM's path 8.5 to 8.5, the helpers' glue 3.6
to 3.6, the iterators 0.0 to 0.0. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, the cuts' binary against this one;
the tiers are the same, the pass skipped on the image row and on the
cached run, the self-check's program from its sources prepared once
without the copy): the synchronous JIT row 5,160.2 to 5,157.5 million
instructions (-0.1%) and 7,381.0 to 7,332.3 by the estimate (-0.7%),
its indirect branches 10.5 to 10.6 million (+1.2%) and its
mispredictions 30.2 to 30.6, the image row 3,374.3 to 3,328.7 (-1.4%)
and 5,043.5 to 4,967.1 by the estimate (-1.5%), the cached run 3,464.0
to 3,408.8 (-1.6%), the interpreter 11,068.3 to 11,065.9 (within
0.05%); the image 9,770,928 to 9,770,928 bytes (unchanged). The four
benchmarks and hello by user-space instructions (perf stat, the JIT
synchronous, in millions): primes 266.0 to 265.8 (-0.1%), strings
443.0 to 442.6 (-0.1%), records 160.9 to 160.7 (-0.1%),
json_round_trip 843.9 to 843.1 (-0.1%), hello 5.47 to 5.20 (-4.9%).
The four judges byte-equal, the conformance suite 55 of 55 on both
tiers, 407 tests. Since stage 0 the check row 2,889.9 to 1,547.9
(-46.4%), since the study's binary 3,085.3 (-49.8%). Next in AW1's
order: stage 5b, the code objects decoded on demand, then stage 6.
AW18. Stage 5b of the new backend: the code objects decoded on
demand. The second half of stage 5 of AW1's order (the load), on
2026-10-12, measured as AW1 prescribes against stage 5a's binary
(16a0dd6). The program of an image, and of an entry of the cache keyed
by the sources, was decoded whole at the load, 32.2 million
instructions on the checker's image run (2.1%, binary::decode
inclusive in stage 5a's profile), most of it the ops of 946 code
objects whose machine code the image carries and the run never reads as
ops, with their spans, their types and their jump tables. Now a code
object's head (the name, the module, the kind, the function, the
parameters, the locals, the read-only flags, the constants) is decoded
with the program, and its body (Body in bytecode.rs: the ops, the
spans, the types, the tables) is decoded at its first read:
write_code writes the body as a length-prefixed block after the head
(encoding 8), read_code keeps the block's bounds in the shared bytes
(binary::Encoded: an Arc of the program's encoding, which
decode_shared takes and decode makes from a slice, and the image
holds its program as such an Arc), and Code::body decodes it
through a OnceLock, which the compile thread of AU15 and the
interpreter may reach at once, checked then as the file's loader checks
a body (file::check_body against file::Limits, the counts of the
program's tables, filled in once the program is read; a body that does
not decode stops the run as a corrupt op would, the file's loader
having no body to check at the load). Every read goes through
Code::body, ops, spans, types and tables, every write through
body_mut and set_body (the compiler's emit, the jump patches, the
pass of AU17, the expansion of AU50), and the interpreter's loop binds
the body once per frame beside the code object; a program from the
compiler or from the bytecode file holds every body decoded, as before,
and file::check checks the bodies it finds decoded. What an image run
decodes: the module constants that are literals (literal_constant
reads their two ops at Jit::new), the bodies the interpreter runs or
the hand-backs reach, and nothing else; a run from the cache keyed by
the sources decodes each body as the JIT compiles it or the interpreter
enters it. A test in tests/native.rs holds the bodies undecoded after
the decode, decoded by their first read, equal to the encoder's, and a
block cut short refused with the program. The measure in full
(callgrind under WSL on the release build for Linux, the images built
under valgrind --tool=none, against stage 5a's binary measured the
same way in AW17, the reference AU34's 44782aa): the check row 1,547.9
to 1,528.5 million instructions (-1.3%), the parse row 701.6 to 696.2
(-0.8%), the compile row 2,743.6 to 2,719.7 (-0.9%); the ratios by
instructions against the reference's rows (441.6, 284.7 and 365.6)
3.46, 2.45 and 7.44 against the gate's 3 (3.51, 2.46 and 7.50 after
AW17); the Rust front end's own rows within 0.2% of stage 5a's (check
173.9, parse --json 246.4, compile 450.9). The check row by
category, AW17's table against this one, in millions: the load 26.1 to
10.0, the generated code 800.8 to 800.8, the comparisons 6.5 to 6.5,
the counts and drops 131.0 to 131.0, mimalloc 79.8 to 76.8, the hashing
and equality 35.4 to 35.2, the natives 255.8 to 255.8, the VM's own
79.5 to 79.6, the records 46.1 to 46.1, the texts and copies 74.4 to
74.3, the calls through the VM's path 8.5 to 8.5, the helpers' glue 3.6
to 3.6, the iterators 0.0 to 0.0. AT1's rows on the frozen self-check
(tools/measure_size.sh under WSL, stage 5a's binary against this one;
the tiers are the same, the bodies decoded as the JIT compiles them on
the JIT rows and as the interpreter enters them on its row, from the
image's bytes on the image row and the cached run): the synchronous JIT
row 5,157.5 to 5,161.6 million instructions (+0.1%) and 7,332.3 to
7,479.8 by the estimate (+2.0%), its indirect branches 10.6 to 10.5
million (-1.6%) and its mispredictions 30.6 to 30.1, its
instruction-cache misses 88.8 to 98.8 million and its last-level misses
3.2 to 3.7 (the estimate's rise is theirs: the generated code's
instructions the same, 1,617.9 million, with its misses 63.3 to 68.0
million, and the helpers' (runtime.rs) 304.8 million the same with
their misses 4.1 to 6.7, the same functions placed differently in the
cache's sets; the instructions within 0.1%), the image row 3,328.7 to
3,311.8 (-0.5%) and 4,967.1 to 4,965.0 by the estimate (within 0.05%),
the cached run 3,408.8 to 3,392.8 (-0.5%), the interpreter 11,065.9 to
10,942.5 (-1.1%); the image 9,770,928 to 9,770,928 bytes (unchanged).
The four benchmarks and hello by user-space instructions (perf stat,
the JIT synchronous, in millions): primes 265.8 to 265.8 (unchanged),
strings 442.6 to 442.6 (unchanged), records 160.7 to 160.7
(unchanged), json_round_trip 843.1 to 843.1 (unchanged), hello 5.20
to 5.20 (unchanged). The four judges byte-equal, the conformance suite
55 of 55 on both tiers, 408 tests. Since stage 0 the check row 2,889.9
to 1,528.5 (-47.1%), since the study's binary 3,085.3 (-50.5%). Stage 5
is done. Next in AW1's order: stage 6, AU50's expansion measured again
under the new convention.
AW19. Stage 6 of the new backend: AU50's expansion measured again
under the new convention, and left off. The last item of AW1's order,
on 2026-10-12, measured as AW1 prescribes on stage 5b's binary
(0f17f67): the three rows of AU58's measure with the images built under
RENYI_NATIVE_INLINE=1 (the lane's probe_inline.sh,
study/5b_inline/) against the same binary with the expansion off,
stage 5b's rows. AW1 estimated that with the convention of stage 1 the
expansion of a callee of at most twelve ops would remove the 30
instructions a direct call still costs, about 25 million on the check
row; the measure says the opposite: the check row 1,528.5 to 1,585.3
million instructions (+3.7%), the parse row 696.2 to 718.6 (+3.2%), the
compile row 2,719.7 to 2,784.0 (+2.4%). By category on the check row,
the generated code itself falls, 800.8 to 789.0 million, and everything
around it rises: the counts and drops 131.0 to 148.1, mimalloc 76.8 to
91.7, the VM's own 79.6 to 107.4, the records 46.1 to 50.4, the calls
through the VM's path 8.5 to 10.2. The counts say why:
Composite::free_block 637,423 to 1,060,403 calls, release_last
737,168 to 1,114,125, mi_free 1,013,869 to 1,448,701,
rt_pair_record 67,784 to 252,115 and rt_split_pair 20,590 to
58,778, rt_call 30 to 4,535, while rt_truncate falls 97,275 to
29,521 with the frames the expansion removes. The stages since AU50's
measure gave a direct call what the expansion cannot give an expanded
callee: a read-only parameter passed borrowed (AW5) is stored into the
region's slot as an owned value and released at the region's end,
423,000 more frees and 377,000 more releases; a record of two fields
returned as a pair of cells to a direct caller (AW9) is built as a
record inside the expansion (rt_pair_record) and split by the caller
(rt_split_pair); and the code objects that grew past the direct
path's shape take the helper path (rt_call). The expansion stays off
unless RENYI_NATIVE_INLINE=1, as AU50 left it; the mechanism, its
tests (tests/inline.rs) and the hand-back stay, so that it can be
measured again when the convention changes. No code changes in this
stage. With it, every stage of AW1's order is done: the check row
stands at 1,528.5 million instructions, 3.46 times the reference's
441.6 against the gate's 3 of AU35 (ii) (6.99 at the study, AW1), the
parse row at 696.2 (2.45) and the compile row at 2,719.7 (7.44); the
road from here is the owner's decision.
AW20. The owner's answer after AW1's order: road (B), the new code
generator, its design study first. Asked on 2026-10-12 after stage 6
(AW19), with every stage of AW1's order done and the check row at
1,528.5 million instructions, 3.46 times the reference against the
gate's 3 of AU35 (ii) (the parse row 2.45, the compile row 7.44). The
question offered four roads: a second round of the checker's own cuts
(recommended: the parser's result records read after their cursor,
AU55's Done rewrite; a few percent, days, the gate still out of
reach), road (B) of AW1 (a new code generator with the operand stack
and the locals in registers, the frame record lazy, the counts elided
by dataflow; AW1's estimate about 10% of the run more than (A)'s
stages, three times the work and months without a measure), the
emitter's round for the compile row, and the switch of the binary's
front end at 3.46 with the gate relaxed or a turn to the other
candidates. The owner chose road (B). The study it asks for is the
handoff's section "Stage 31, the new code generator (road (B)): the
design study (session 14)", measured on stage 5b's binary (0f17f67) by
AU58's measure with the interpreter's profile, the Cranelift IR of the
hottest small functions and four micro programs of the lane: the
generated code is 800.8 million of the 1,528.5, a direct call costs
about 100 instructions beside its body and a typed field read about 58,
the loads, moves, stores, field reads, constants and dups are 26.0
million of the run's 49.5 million ops; the study finds (B) buildable on
the Cranelift tier as it stands in four measured stages (the operands
in registers, the locals in registers, the frame record lazy, the
counts by dataflow), about 340 million in all by its estimates, the
check row to about 1,190 million, 2.7 times the reference; its
questions and the owner's answers are decision AW21. (user)
AW21. The owner's answers after the study of road (B): the Cranelift
tier evolved in four measured stages, B2 then B3, B1 and B4, a held
value as its three words, the old measure with the micro programs, the
expansion measured again after B3, the pair slots folded into B3, the
template tier unchanged, the checker's cuts as the reserve. Asked on
2026-10-12 after the study (AskUserQuestion, two batches of four, every
recommended option taken): (1) (B) built on the Cranelift tier as it
stands in four stages, each measured and kept by the owner's rule, over
a rewrite of codegen.rs as one piece (AW1's framing, months without a
measure) and over a third tier beside the two; (2) the order B2 (the
operands in registers), B3 (the locals in registers), B1 (the frame
record lazy), B4 (the counts by dataflow), the largest first, over B1
first and over B3 before B2; (3) a held value as its three words, the
tag and the two payload words of the 24-byte Value as it lies on the
stack, a small text held whole, over two words with the small texts of
AU26 left on the stack and over the tag elided where the checker's type
is exact (a maybe and a guarded value break it; after (B), if at
all); (4) each stage measured as AW1's were (AU58's measure with the
table by category, AT1's rows, the four benchmarks, the four judges,
the conformance suite on both tiers) with the lane's four micro
programs per turn (calls_typed, calls_boxed, boxed_fields,
boxed_moves) recorded in the entry, kept by the rule of 2026-10-12
(the check row down by at least 0.5%, or AT1's synchronous estimate
down at all), over the gate measured once at (B)'s end and over the
micro programs moved into bench/micro/; (5) AU50's expansion measured
again at B3's end as part of its measure and turned on by default if it
pays, over its removal and over leaving it; (6) the pair slots of AW9
folded into B3, a pair slot two held values and the pair_* machinery
removed, over keeping both; (7) the template tier unchanged through
(B), its calls into Cranelift bodies through the trampolines with the
arguments on the VM's stack and the callee's prologue taking them into
registers, over register arguments from template code at B3 and over
the tier's retirement; (8) the reserve if B2 and B3 measure at half
their estimates: a second round of the checker's own cuts (the parser's
result records read after their cursor, Done rewritten), over
stopping at B4 and over the natives' round. The order: B2, B3 (with the
expansion measured again), B1, B4, each with its entry and its
paragraph in the handoff's section of stage 31. (user)
AW22. Stage B2 of the new code generator: the operands in
registers. The first stage of road (B) in AW21's order, on
2026-10-12, measured as AW21 prescribes against stage 5b's binary
(0f17f67, the base of road (B)). A new operand kind in the analysis of
the Cranelift tier, Abs::Held(type) in native/infer.rs: a value
held as the three words of its 24-byte Value in Cranelift variables,
the tag word and the two payload words, as a Load of a boxed slot
reads them, with the type the checker noted as Boxed carries it; what
a load of a boxed slot, a boxed constant, Nothing, a module constant,
a field read (Field, LoadField and TakeField, on every path: the
field's words read in place with one more reference, moved out of a
record held once, or taken off the stack where the helper pushed them),
a loop's item (IterNext, the item's words from the list's block or
from the helper's push) and a Dup of a held value push, when the tier
holds values (analyse's held: the Cranelift tier does; the template
tier, the expansion of AU50 and the hand-back's rebuild of the expanded
frames do not). The VM's stack is written only where something reads it
there. An op whose result goes on the stack (a list, a map, a pair, a
range through the helper, a record or a variant, a with, a call
through a helper or whose result is a value, a method call, a value
called, a text's conversion, a concatenation, an unpack, a failure
unwrapped, the query terminals) writes every held operand under its
operands back first, three stores at the top each (spill_below,
spill_all_held), so that a held operand never lies under one on the
stack on the straight line, and the analysis's push! keeps the same
rule (a held operand under a pushed value on the stack is spilled in
the state). A helper that takes its arguments from the stack
(helper_on_stack, call_typed, call_in_place, list_at_in_place,
update_in_place) finds them written there by box_position, which
inserts a held operand by its index through rt_insert_held where
values lie above it (a join of paths can leave one under a value). A
direct call reads a held operand of a typed parameter from its words,
its tags tested there, with no cell for the frame to clear
(call_direct); a comparison in place reads a held operand's tags and
payload words from its registers (operand_byte, operand_word: the
small texts, the small Integers, the variants by the type and the tag,
the borrowed operands of AU13 now held, is_value); a test of the top
(IsVariant, IsNothing, IsFailure, JumpIfAbsent,
JumpIfFailure, a condition) reads the tag from the first word and a
Boolean from the second (unbox_held_top, take_bool_held); a store
writes the three words into the slot; an iterator over a held list
takes the words into its slot; a Return of a held value unboxes it
from the words for a direct caller or leaves it where the frame's first
slot was (leave_held_inline); the counts are raised and lowered in
the words (retain_words, release_words, the last reference dropped
through rt_drop_at on a scratch slot of the machine stack). Off the
straight line: a landing writes every held operand back at its index
through rt_insert_held before the floor cuts the stack
(spill_all_held_by_index; the landings keyed by the whole operand
stack, and the analysis's handler state the same with every held
operand spilled), an exit from a state with held operands goes through
a cold block per state that writes them back first (exit_for_state,
emit_exits), the helpers that leave the frame (rt_fail,
rt_check_failed, rt_unhandled) find them written back, a hand-back
carries the three words in its buffer and rt_deopt reads them as the
value (DeoptPoint kind code 7, image format 9 to 10), a frame left
releases the held operands below the result from their registers
(leave_frame_inline), and UnwindStack releases the held operands
above the mark. The analysis computes its entry states again from the
final slot kinds once they settle (the clean run at the end of
analyse), so that no state carries a kind an earlier round's slot
kinds gave an op: a load of a slot that was an Integer before it was
boxed pushed a register then and pushes a held value now, and their
join, a value on the stack, is what the generated code, which pushes by
the final kinds, would not have (the generator's state is held to the
analysis's at every op in debug builds, as before). A test in
tests/native.rs takes a held operand through an overflow's hand-back,
a failure's landing under an otherwise and a loop's item returned
from the loop, the two tiers and the interpreter agreeing. Nothing
changes for the template tier, the bytecode file, the emitters and the
judges. The measure in full (callgrind under WSL on the release build
for Linux, the images built under valgrind --tool=none, against stage
5b's binary measured the same way in AW18, the reference AU34's
44782aa): the check row 1,528.5 to 1,482.3 million instructions
(-3.0%), the parse row 696.2 to 680.4 (-2.3%), the compile row 2,719.7
to 2,661.2 (-2.2%); the ratios by instructions against the reference's
rows (441.6, 284.7 and 365.6) 3.36, 2.39 and 7.28 against the gate's 3
(3.46, 2.45 and 7.44 after AW18); the Rust front end's own rows within
0.1% of stage 5b's (check 173.6, parse --json 246.4, compile
450.7). The check row by category, the study's table against this one,
in millions: the generated code 800.8 to 756.8, the natives 255.8 to
254.2, the counts and drops 131.0 to 131.0, the VM's own 79.6 to 79.6,
mimalloc 76.8 to 76.8, the texts and copies 74.3 to 73.8, the records
46.1 to 46.1, the hashing and equality 35.2 to 35.4, the load 10.0 to
10.0, the calls through the VM's path 8.5 to 8.0, the comparisons
through the helper 6.5 to 6.5, the helpers' glue 3.6 to 3.6, the
iterators 0.0 to 0.0; rt_drop_at 313,620 to 313,620 calls, rt_deopt
0 to 0, rt_insert_held 0 (none before). The four micro programs of
the study per turn (micro_b.sh, the generated code; the interpreter
in brackets): calls_typed 119 to 120 (+0.8%; 1112 to 1112),
calls_boxed 215 to 201 (-6.5%; 1181 to 1181), boxed_fields 131 to
123 (-6.1%; 1053 to 1053), boxed_moves 145 to 120 (-17.2%; 1023 to
1023). AT1's rows on the frozen self-check (tools/measure_size.sh
under WSL, stage 5b's binary against this one): the synchronous JIT row
5,161.6 to 5,195.4 million instructions (+0.7%: the generated code
1,617.9 to 1,558.8 million on this row, and the JIT's own work up by
about 93 million, Cranelift's register allocation over more variables
with longer live ranges and the analysis's clean run, which doubles
analyse to 16.0 million; an image run does not pay it) and 7,479.8 to
7,372.5 by the estimate (-1.4%, with the instruction-cache misses 98.8
to 87.8 million), its indirect branches 10.5 to 9.8 million (-6.6%) and
its mispredictions 30.1 to 30.8, the image row 3,311.8 to 3,219.2
(-2.8%) and 4,965.0 to 4,778.3 by the estimate (-3.8%), the cached run
3,392.8 to 3,299.5 (-2.7%), the interpreter 10,942.5 to 10,942.0
(within 0.05%); the image 9,770,928 to 10,315,120 bytes (+5.6%: the
spills, the exit per state and the counts in the words). The four
benchmarks and hello by user-space instructions (perf stat, the JIT
synchronous, in millions): primes 265.8 to 266.0 (+0.1%), strings
442.6 to 444.0 (+0.3%), records 160.7 to 155.2 (-3.4%),
json_round_trip 843.1 to 841.7 (-0.2%), hello 5.20 to 5.22 (+0.4%).
The four judges byte-equal, the conformance suite 55 of 55 on both
tiers, 409 tests. Since stage 0 the check row 2,889.9 to 1,482.3
(-48.7%), since the study's binary 3,085.3 (-52.0%). Kept by the
owner's rule (the check row down by more than 0.5%). Against the
study's estimate of about 180 million for B2, the stage took 46.2
million off the check row: a load that feeds a direct call's boxed
parameter (Load Call and LoadMove Call, 2.8 million pairs in the
interpreter's profile of the run), a with, a construct or a native
that reads the stack still writes the value where the callee's frame,
the update or the native reads it, three stores where the copy was
three loads and three stores, and only the loads whose consumer reads
in place (a comparison, a test, a store into a slot, a field read, a
typed parameter, a Return) stopped copying; at_position, the
hottest body, kept 267 of its 305 stores, its calls' arguments and its
with among them. B3 moves the parameters into registers, and a direct
call can then pass a held argument's words without the stack: the
study's split of the estimate between B2 and B3 was wrong where its sum
need not be, and B3's measure will say. Next in AW21's order: B3, the
locals in registers, with AW9's pair slots folded in and AU50's
expansion measured again at its end.
AW23. Stage B3 of the new code generator measured and left off; the
leak of stages 2b to B2 found and fixed. The second stage of road (B)
in AW21's order, the locals in registers, was built on 2026-10-12 and
measured as AW21 prescribes against stage B2's binary (2758464). As
built: a new slot kind in the analysis of the Cranelift tier,
SlotKind::Held(type) in native/infer.rs, every slot that holds a
value (a value parameter, a local a store of a value fills; not an
iterator, a mark or a deadline slot) held as the three words of its
Value in Cranelift variables, a pair slot of AW9 as its two fields'
six words (Abs::Pair taking no cell, the cells past the locals gone),
a Load pushing the slot's words held and a Store moving a value's
words into them, LoadField, TakeField and JumpByTag reading the
holder from the words, a with on a slot updating the block in place
from them, a direct call passing a value argument as its three words in
registers (three i64 per value parameter in the direct signature, the
callee's prologue taking them from the registers, the trampoline loading
them from the frame's cell), the slot's cell on the VM's stack written
only where the VM reads it (before a helper that reads the slot by its
index, before a helper that leaves the frame or crashes in it, on an
exit with the frame alive, and by a hand-back, whose buffer carries
every held slot's words; image format 11), the entry at a loop header
loading a held slot's words from the frame as the interpreter left them
and a pair slot's through rt_pair_resume, and a frame left through one
leave block per body that releases every slot of the code object's own
from its registers (the inline leaves of AW4, AW9 and AW22 and the leave
through rt_truncate gone). Every gate passed: the four judges
byte-equal, the conformance suite 55 of 55 on both tiers, 410 tests. The
measure against B2: the check row 1,482.3 to 1,583.1 million
instructions (+6.8%), the parse row 680.4 to 705.5 (+3.7%), the compile
row 2,661.2 to 2,821.4 (+6.0%); the generated code 756.8 to 867.8
million; AT1's synchronous row 5,195.4 to 5,644.1 (+8.6%) and its
estimate 7,372.5 to 8,061.6 (+9.3%), the image row 3,219.2 to 3,378.1
and 4,778.3 to 5,250.4 by the estimate (+9.9%), the image 10,315,120 to
14,959,912 bytes (+45.0%); the micro programs per turn calls_typed 120
to 133, calls_boxed 201 to 225, boxed_fields 123 to 121,
boxed_moves 120 to 121; the benchmarks primes +1.5%, strings
+1.9%, records +4.0%, json_round_trip +0.7%; AU50's expansion
measured again on it (AW21), the check row 1,598.0 with it on (+0.9%),
left off. The study's estimate for B3 was about 90 million off the check
row; the measure put 100.8 million on.
Looking for the rise found a leak instead. On the check row B3's binary
freed 870,960 record blocks of the 870,960 allocated, B2's 637,621: B2's
Cranelift tier left 233,339 blocks per run of the checker on
compiler/bodies.ry (the interpreter and the template tier free every
one), and the stages' profiles say since when: mimalloc's frees matched
its allocations through stage 2a and fell short from stage 2b (AW9) on,
1,978,953 allocations to 1,777,179 frees there. The blocks by type (a
probe counting Composite::allocate and free_block, never committed):
91,945 tokens with their spans and kinds, the token lists of every file
read, held by 476 leaked Cursor records of the parser; the parser's
if_statement leaks one cursor per if statement (a file with one
function holding one if leaks; for, match and repeat do not; the
lane's bisect/). The mechanism: owned_slots (AW4), the analysis of
the slots a frame's leave releases, followed the ops only where the
abstract interpretation had left an entry state; since AW9 a call that
returns a record of two fields under an otherwise takes the success
path straight to the region's end (otherwise_end), and the
PopHandler and the Jump it skips have no state, so the owned
analysis stopped there: every op after the region counted as unreached,
every slot owned there (a harmless release of Nothing cells), but a
loop's back edge never carried the body's stores to the header, and a
frame leaving by the loop's exit path, the header's state being the
entry's, skipped the pair slots the body had stored: in if_statement,
otherwise_word and if_word, two Eaten pairs of a flag and a
cursor, left in their cells at the return. The fix: owned_slots passes
the state through an op the analysis left without a state, as the op's
kind says (the Store rule's scalar test reads the state where there is
one), so that the ops after the region and the back edge are reached and
every slot counts only where no path reaches an op. With it the probe's
run of the checker frees 870,960 of 870,960, the parse of
compiler/effects.ry 5,611 of 5,611 (2,333 leaked before). A test in
tests/native.rs
(the_owned_analysis_reaches_past_an_otherwise_region) runs the
analysis on a function of the shape of if_statement, a loop whose body
calls a pair-returning function under otherwise and stores two more
pairs, and holds the two pairs owned at the return and the region's end
reached with a state of its own; it fails on the analysis before the fix
(every pair unowned at the return). B3's leave did not depend on the
owned analysis and freed everything, which is why B3's measure showed
the leak as a rise; B3 still took owned at a loop header for its pair
slots' resume, right as well with the fix.
The fair base, stage B2 with the fix (renyi_b2fix, the commit of this
entry's code), measured the same way: the check row 1,482.3 to 1,493.5
million (+0.8%: free_block 47.2 to 61.1 million, release_last 51.9
to 60.2 and mi_free 22.3 to 27.6 for the blocks now freed, against
rt_truncate 18.4 to 3.8, the leave releasing by the precise states
where every slot counted before, its calls 97,275 to 15,725), the parse
row 680.4 to 688.6 (+1.2%), the compile row 2,661.2 to 2,673.0 (+0.4%);
the ratios by instructions 3.38, 2.42 and 7.31 against the gate's 3; the
generated code 756.8 to 757.4 million; AT1's synchronous row 5,195.4 to
5,188.5 (-0.1%) and its estimate 7,372.5 to 7,394.5 (+0.3%), the image
row 3,219.2 to 3,203.6 (-0.5%) and 4,778.3 to 4,743.0 by the estimate
(-0.7%), the cached run 3,299.5 to 3,287.1, the image 10,315,120 to
10,330,704 bytes (+0.2%); the micro programs within one instruction per
turn (calls_typed 120, calls_boxed 202, boxed_fields 122,
boxed_moves 119); the benchmarks unchanged. B3 against this base: the
check row +6.0%, the parse row +2.5%, the compile row +5.6%, AT1's
synchronous row +8.8% and its estimate +9.0%, the image row +5.4% and
+10.7% by the estimate, the image +44.8%, calls_typed +10.8% and
calls_boxed +11.4% per turn, the benchmarks +0.7% to +4.1%; the
helpers equal (release_last 383.4 to 383.3 million inclusive,
free_block 215.1 to 215.0, rt_drop_at 155.1 to 159.0), the whole of
the rise in the generated code, 757.4 to 867.8 million (+14.6%) less
what left (Pinned::insert 11.2 to 0.6, rt_truncate 3.8 to 0,
rt_insert_int 3.1 to 0.1, the clones 43.3 to 29.0 inclusive), and in
every body: per call at_position 506 to 509, token_at 170 to 191,
lex_word 607 to 662, next_step 262 to 313, find_binding 794 to
938, resolve 228 to 275, substitute 295 to 404, moved 95 to 130
(the lane's study/b3/map.txt against study/b2/). The cause as read
from the IR: a slot held as three SSA values lives across the whole
body, so Cranelift spills most of them around every call and moves them
through every block's parameters (a loop header carrying ten words where
B2 carried seven), and the leave block takes its mode, status and result
words as parameters that a small callee materialises before the jump;
the cells of the VM's stack cost less than the spills and the moves that
replaced them. Left off by the owner's rule (AW21: kept only when the
check row falls by 0.5% or AT1's estimate falls at all), the owner's
answer of 2026-10-12 with the recommended options: B3's code not merged
(its diff with the fix and the test on top is the lane's
scratch_b3/b3_as_built.diff, its binary renyi_b3, its study
study/b3/ and study/b3_inline/), this entry's code the fix and its
test alone, and B1 next in AW21's order, the frame record lazy, on the
fixed base. A held slot as one word (the pointer of a record whose type
the checker settled, the tag implied) is the variant B3 did not try,
noted for the day B1 and B4 fall short, beside AW21's reserve.
AW24. Stage B1 of the new code generator: the frame record lazy. The
third stage of road (B) in AW21's order, built on 2026-10-13 and
measured as AW21 prescribes against stage B2 with the leak fixed
(renyi_b2fix, the tree of AW23's commit 1048e84, the base AW23 named).
As built: a direct call between compiled bodies pushes no record on
Vm::frames. The callee's body keeps a node in its machine frame
instead (FrameNode in vm.rs: the link to the caller's node, the code
object, the base, the grant the signature passed, and whether the record
is made), linked as the head of the chain NativeState::head names by
the prologue of a body entered directly (link_node in codegen.rs:
one load and six stores, where the record cost four loads and seven
stores at the call and the prologue a check of the frames' room) and
unlinked by every return (unlink_node in return_with, which every
way out of a body goes through); a body entered through its trampoline,
whose record the interpreter or the template tier pushed, is marked made
from the start (direct 0), a direct call's not. The records are made
by Vm::record_frames (the test of the head inline on the path of every
call through the VM, the walk a call of its own, record_chain), which
walks the chain from the head to the first node marked made, pushes a
record per node before it, innermost first and reversed in place into
call order (the innermost's pc the one a helper synced beside the head,
NativeState::head_pc, since only the innermost frame's pc locates a
crash and every helper that raises an interrupt syncs first; an outer
one's 0, as a call's record starts; the handler base the handlers'
height now, since the generated code pushes no handler and whatever ran
above these frames has taken its own back), marks them, cuts their links
and leaves the head null, so that a null head or a marked one says the
innermost frame has its record (a select at every entry, which would
have let a null alone say it, cost 4.0 million on the check row in the
second build below, more than the readers' test of the mark costs
there); it runs before anything reads a frame by its record:
push_frame_in_place (a call through the VM's path, rt_call, a
callback from a native, a function value), interrupt in runtime.rs
(every interrupt parked, status's too: the frames are abandoned by
their records on the way out, and the innermost's pc locates a crash),
rt_deopt (the frame goes to the interpreter by its record) and
denied (the owner's name walks the records). The readers that need no
record: effective_grant reads the unrecorded head's grant first (such
a frame is the innermost of all, since every way a frame goes above it
makes the records first and the template tier's calls run above a made
chain), frame_grant takes the enclosing grant from it
(innermost_grant_index; rt_frame_grant unchanged, right for the
template tier too, whose own record is on top) and
push_frame_in_place, the records made, from the record on top
(frame_grant_under), sync_pc writes head_pc while the head's
record is unmade, else the record's pc, and leave_frame (rt_fail,
rt_unhandled, rt_check_failed) cuts the stack to the node's base
when the record is unmade, with no handler of its own to take back. The
leave in generated code pops the record only when the node says it is
made (a cold block, the handlers' height restored from the record);
push_frame_inline keeps the argument moves and the grant;
rt_grow_frames stays for the template tier. The template tier, the
trampoline (which reads the record's grant, on top for every trampolined
frame), the interpreter, the bytecode and the emitters are untouched;
code format 23 to 24, since the generated code's view of NativeState
changed. The tests:
direct_calls_make_their_frame_records_only_when_a_helper_reads_them in
tests/native.rs (a crash three direct calls deep located at the
innermost line, which the chain blinded puts at main's; a frame handed
back two direct calls deep inside a loop, its callers taking the big
result through hand-backs of their own; a denial under a sandbox inside
a narrowing callee called directly, whose message names that callee and
its grant; each against the interpreter), and AW6's test of the grant
renamed, its room check gone. Every gate passed: 411 tests, the four
judges byte-equal, the conformance suite 55 of 55 on both tiers.
The measure against renyi_b2fix: the check row 1,493.5 to 1,482.7
million instructions (-0.7%), the parse row 688.6 to 685.3 (-0.5%), the
compile row 2,673.0 to 2,656.9 (-0.6%); the ratios by instructions 3.36,
2.41 and 7.27 against the gate's 3 (the Rust rows within 0.1% of the
base's); the generated code 757.4 to 744.9 million, the calls through
the VM 8.0 to 8.2, the counts and drops 130.6 to 130.6, the natives
254.2 to 254.2; AT1's synchronous row 5,188.5 to 5,228.4 (+0.8%) and its
estimate 7,394.5 to 7,557.1 (+2.2%), the image row 3,203.6 to 3,208.5
(+0.2%) and 4,743.0 to 4,795.5 by the estimate (+1.1%), the cached run
3,287.1 to 3,291.7 (+0.1%), the interpreter 10,937.5 to 11,012.8
(+0.7%), the image 10,330,704 to 10,383,184 bytes (+0.5%); the micro
programs per turn calls_typed 120 to 116, calls_boxed 202 to 199,
boxed_fields 122 to 122, boxed_moves 119 to 120; the benchmarks
primes +0.2%, strings +0.7%, records +0.5%, json_round_trip
+0.1%. Four builds were measured on the way, the earlier ones kept in
the lane (study/b1_first, study/b1_refined2 and their logs): the
first (the synced pc in the node, the records collected into a vector,
every reader testing the head's mark) at 1,485.8 million on the check
row (−0.5%) and 7,547.3 million by AT1's estimate (+2.1%), whose
profiles on the self-check (which calls function values 446,259 times
through the VM's path and so records most of its frames: record_frames
21.2 million of its own, frame_grant 12.5 to 17.4 million, the
allocator 161.4 to 176.0 million) and on the synchronous row (the
runtime's helpers 10.6 million up, the code generator's own 2.5 million)
led to the second (the pc beside the head, no vector, the chain's
invariant tightened so that a null head alone said the record was made,
by a select at every entry) at 1,487.9 million (−0.4%: the select cost
4.0 million of generated code) and 7,537.3 million (+1.9%), whose
interpreter profile put the 161.6 million of its row's rise (+1.5%) in
record_frames called out of line at each of 5,407,462 pushes through
the VM (97.3 million of its own and 81.1 million of spills in
push_frame_in_place, against 21.6 million saved by
frame_grant_under), which led to the third (the select gone, the
readers testing the mark again) and the fourth (the test of the head
inline, the walk a call of its own), measured together as the build
above. What remains on AT1's rows is structural: the self-check records
most of its frames, and a body entered through its trampoline writes a
node its record makes needless, which the tiered runs (the synchronous
row, the benchmarks) pay at every such entry; a later stage could let
the interpreter and the template tier leave the record to the chain too,
after which every compiled frame would be a node. The direct calls of
the current compiler, the check row, gain. Kept by the owner's rule
(AW21: the check row down by at least 0.5%, or AT1's synchronous
estimate down at all: -0.7% and +2.2%). Next in AW21's order: B4, the
counts by dataflow.
AW25. Stage B4 of the new code generator: the counts by dataflow.
The fourth and last stage of road (B) in AW21's order, built on
2026-10-13 and measured as AW21 prescribes against stage B1 (renyi_b1,
the tree of AW24's commit d664c2d). As built, three parts. First, a leak
found on the way, since decision AU13, fixed on both tiers:
borrowed_operands in codegen.rs walks back from a comparison or a
call over the pushes just before it and marks them borrowed (decisions
AU13 and AW5), and the walk crossed a position another path enters at,
so that the value of an if expression or of an otherwise compared at
once had the push of the branch before the comparison marked borrowed
while the other branch's push, moved out of its slot, was released by
nobody: 100 KB a turn in the probe (scratch_b4/leakprobe.ry in the
perf lane: 2.4 GB resident over 20,000 turns on the Cranelift tier and
on the template tier, 20 MB on the interpreter). jump_targets marks
every target of a jump, a handler's landing or a loop's exit, and the
walk (pushes_before, simple_pushes) stops before one;
accepted_params walks the same way, so that the bits every caller
computes stay a function of the ops. Second, on the Cranelift tier a
LoadField of a slot that is not a pair, pushing a value, and a
Global are pushed borrowed for their consumer (a comparison, a typed
or in-place entry, a direct call's accepted parameter): the fast paths
(the field read in place by the holder's static type or through the
site's cache; the constant copied from the VM's table) skip the retain,
since the holder's slot, which no op between the push and the consumer
writes, and the table, which keeps a constant once built, hold the value
through the consumer (a field is not borrowed where its holder is moved
into the same call); the helper paths (rt_load_field, which
synthesizes a guarded field, and rt_global, which builds the constant)
push a value with a reference of its own, which the generated code notes
in a Cranelift variable, slow_owned (bit i for the consumer's
operand i, cleared by a fast path and set by a helper path,
note_dynamic_push), and every consumer masks its static bits by it at
run time (runtime_mask: rt_compare, rt_call_typed, the in-place
shim and the direct call's borrowed_params; compare_sum_variants,
list_at_in_place and retain_borrowed_arguments release or retain
such an operand by its bit); a helper that fails with borrowed operands
below it gives them a reference first (check_status_over_borrowed,
Borrowed::below), since whoever releases the frame counts every
operand as owned; a typed field goes in a register and stops the walk,
since its unboxing may hand the frame back with the operands below it on
the stack, and a TakeField is never borrowed, since it moves the field
out of a record held once. The template tier keeps the shorter walk
(fields false): its field reads retain and its helper paths give
nothing back, as AW21 (7) asks. Third, a store releases the slot's old
value only where the owned analysis of AW4 says the slot may hold a
reference at the op (release_in_slot): a fresh local, a slot moved out
at its last read and a slot holding a typed value hold Nothing or a
plain value and need no release. The study's third lever, a Load of a
slot dead after it treated as a move where the emitters wrote none, is
not built: the emitters' rule (AU55) is syntactic, the loads it leaves
are read again on some path (a parameter read in a loop, a name
mentioned twice in a statement), and a path-sensitive liveness in the
tier would find the rest, unsized. The interpreter, the bytecode, the
emitters and the code format are untouched: the generated code's
contract with the VM did not change, and an image of this version built
before the stage runs, with the leak of the first part. The tests:
tests/leaks.rs, a new test binary with a counting allocator around the
system's, where a program run twice on a tier (the Cranelift tier, the
template tier, the interpreter) holds no more after its second run than
after its first, 100 KB a turn otherwise (the joins of the first part,
which held 2,000,617 bytes on the Cranelift tier before the fix; a field
read through the cache and through the helper, an Admin passed where a
User is; a field passed to a direct call; a constant compared and
passed to a typed entry; a store over the value of the turn before; a
constant whose construction crashes with a borrowed operand below it),
and in tests/native.rs
fields_and_constants_borrowed_by_their_consumers_print_as_the_interpreter_prints
and
the_borrowed_walk_stops_where_another_path_enters_and_finds_the_field_reads
(the bits of Borrowed on five functions under both walks). Every gate
passed: 417 tests, the four judges byte-equal, the conformance suite 55
of 55 on both tiers.
The measure against renyi_b1: the check row 1,482.7 to 1,437.8 million
instructions (-3.0%), the parse row 685.3 to 670.0 (-2.2%), the compile
row 2,656.9 to 2,598.6 (-2.2%); the ratios by instructions 3.26, 2.35
and 7.11 against the gate's 3 (the Rust rows within 0.3% of the base's);
the generated code 744.9 to 708.2 million, the calls through the VM 8.2
to 8.2, the counts and drops 130.6 to 131.0, the natives 254.2 to 245.6;
AT1's synchronous row 5,228.4 to 5,172.5 (-1.1%) and its estimate
7,557.1 to 7,477.1 (-1.1%), the image row 3,208.5 to 3,145.7 (-2.0%) and
4,795.5 to 4,680.7 by the estimate (-2.4%), the cached run 3,291.7 to
3,229.1 (-1.9%), the interpreter 11,012.8 to 11,012.8 (within 0.05%),
the image 10,383,184 to 9,561,248 bytes (-7.9%); the micro programs per
turn calls_typed 116 to 117, calls_boxed 199 to 198, boxed_fields
122 to 122, boxed_moves 120 to 113; the benchmarks primes within
0.05%, strings -0.3%, records -1.2%, json_round_trip -0.1%. The
gain is where the study put it, and larger than its estimate of about 30
million: the generated code 744.9 to 708.2 million (the releases at the
stores and the retains at the field reads and the constants gone with
their cold blocks, which the image's 7.9% shows), the natives 254.2 to
245.6 (the in-place entries' shims 290.4 to 282.2 million inclusive: a
borrowed argument is released by nobody), against 0.4 million more in
the counts and drops (33,410 more clones, take_or_clone copying a
borrowed field into an entry that takes it); the frees are unchanged
(rt_drop_at 155.1 million on both builds), so the compiler leaked
nothing through the joins the first part fixes; the interpreter row is
unchanged to five digits and the template tier untouched; boxed_moves
120 to 113 per turn is the store's release gone from its loop. The probe
of the leak on the stage's binary: 31 MB resident on the Cranelift tier
and 21 MB on the template tier over the 20,000 turns, where the base
held 2.4 GB on each. Kept by the owner's rule (AW21: the check row down
by at least 0.5%, or AT1's synchronous estimate down at all: -3.0% and
-1.1%). The four stages of road (B) are measured; what comes next is the
owner's call.
AW26. The second round of the checker's own cuts: the reserve of AW21
(8). The owner's answer after stage B4 (AW25), with the check row at
1,437.8 million instructions and the ratio at 3.26 against the gate's 3:
the reserve of AW21 (8), a second round of cuts in the compiler's own
sources (compiler/*.ry), over the emitters' round and the switch at
3.26. Built on 2026-10-13 on stage B4's binary (renyi_b4, the tree of
commit b4c057b), which the round leaves as it is: every cut is a change
of the Renyi sources, gated by renyi check clean, the canonical layout
and the four judges byte-equal, and kept by the check row of perf stat
on the same binary (the lane's quick_check_row.sh, the base 1,400.7
million on the sources before the round). The profile of B4's check row
attributed by code object (study_map.py) and the callers of
rt_record_copy resolved to the code objects that copy
(copy_callers.py): 109,613 copies, 65,755 of them in the parser's
at_position, 17,036 in the checker's infer, 9,408 in with_nesting,
8,162 in mark_used. Four cuts. (1) The reserve's item: 138 of the
parser's result records (Parsed, Peek, Eaten, the clause records)
read after their cursor now bind the other field first (let look_token
be look.token before look.cursor is taken), so that the cursor read
is the last mention and a TakeField (AU55) instead of a shared read;
the quick row 1,400.7 to 1,389.6 (-0.8%), the copies in at_position
65,755 to 43,120. Less than the reserve expected, and an experiment
settled why: the emitters' liveness rule (AU55) extended so that a write
at a block's own level kills the name, a read before it moving even
inside a loop and across the enclosing statement, measured on the Rust
emitter alone, left the quick row where it was (1,389.4): the VM's pass
of AU17 already moves the last read of every slot by a dataflow over the
bytecode where a program enters it, and an image carries the prepared
program (AW17), so the emitters' syntactic rule has nothing left to find
at run time; the copies came from the sources' shapes, not the rule, and
the experiment is not kept. (2) A record updated into a fresh local,
let updated be checker with vars: checker.vars.append(info), is a
With over a base its slot still holds: the base is pushed with one
more reference, the update copies the record (the checker's 24 fields)
and append copies the list it reads from the shared record; 12 such
sites in bodies.ry, declare.ry and parser.ry are written let
mutable updated be checker and change updated to updated with ...,
the base moved into the local at its last read and the update run in the
slot by AU11's plans (a value that reads the base other than as
x.f.method(args) bound first, so that no update pins the local); the
quick row 1,389.6 to 1,335.7 (-3.9%): infer's 17,036 copies of the
checker and of its typed list on every noted expression,
pop_scope's, fresh's and with_nesting's gone. (3) identifier,
primary and word_primary moved the cursor past the token before the
match on its kind, while the arms for the other kinds read cursor
again (the error paths, the constructs entered at the looked-at token),
so the cursor stayed live across the move, at_position found it shared
and copied it on every call (22,459 in identifier, 13,146 in
primary), and the arms that re-enter at the token paid for a move they
drop; the move now stands in the arms that take it, where cursor is
read for the last time; clause_text and the callers of with_nesting
that pinned the cursor with x.position + 1 or x.nesting + 1 in the
same call bind the number first; the quick row to 1,302.7 (-2.5%);
19,261 copies remain (8,174 in mark_used, a binding updated inside its
scope's list; 5,125 in at_position). (4) The one-line helpers inlined
where they are called and removed: is_word and is_symbol
(token.code is code, 53 sites, 178,401 calls), token_at
(cursor.tokens.at(index) otherwise end_token(cursor), 21 sites,
171,276 calls), moved where its result goes back into the slot it came
from (if look is not x.position then change x to x with position: look
end, 17 sites) and in peek, advance, bump, parse_block and the
misses of eat_word and eat_symbol (6 sites), and var_at in
resolve, the loop that follows a variable's bindings (77,148 calls);
the quick row to 1,277.1 (-1.9%). Every gate passed on every cut: the
four judges byte-equal (382 tests of the whole suite at the end, the
conformance suite among them).
The measure (callgrind, renyi_b4 on the sources after the round
against the same binary on the sources before it, study/cuts2/ against
study/b4/): the check row 1,437.8 to 1,307.5 million instructions
(-9.1%), the parse row 670.0 to 629.5 (-6.0%), the compile row 2,598.6
to 2,468.1 (-5.0%); the ratios by instructions 2.96, 2.21 and 6.75
against the gate's 3 (the gate on the check row 1,324.8 million; before
the round 3.26, 2.35 and 7.11); the Rust front end's rows on the edited
compiler/bodies.ry 173.6 to 174.0 (+0.2%), 246.4 to 246.6 (+0.1%) and
450.4 to 451.0 (+0.1%); the generated code 708.2 to 651.4 million, the
natives 245.6 to 234.4, the counts and drops 131.0 to 94.7, the
allocator 79.7 to 73.5, the records 46.1 to 61.1, the texts and memory
copies 73.8 to 66.6, the hashing 35.5 to 34.8; the record copies 109,613
to 19,266, the calls through the natives' shim 999,647 to 999,410. AT1's
rows, the benchmarks and the micro programs read neither the compiler's
sources nor a changed binary and keep AW25's numbers. By the map, what
remains on the check row is the generated code's own cost per op
(at_position, 56.6 million over 114,188 calls, about 500 instructions
for some fifteen ops a call: the field read, the tag test and the update
in the slot among them), the lexer's loop and its word path
(lex_range, lex_word, next_step, lex_reserved, 103 million:
every character classified through Text.contains and two text
comparisons, every word through four natives), the natives' boundary
(999,410 calls through the in-place shim at about 110 instructions each,
7.6% of the row, the same count as before the round) and the checker's
scans and substitutions (find_binding, 19.0 million by a text
comparison per binding; resolve, substitute, substitute_all);
these are the VM's to cut (the shim's entry, the code per op, the
comparison of two texts) or structural in the sources (the lexer's
tables), and this round's lever, the shapes that share a record or call
a one-liner, is spent. Kept by the owner's rule (AW21: the check row
down by at least 0.5%, here -9.1%). The ratio 2.96 is within the gate of
3 (AU36 (iii), AU58: the check row 1,307.5 million against 1,324.8), the
first time since the gate was set: the switch of the binary's front end
to the compiler written in Renyi, which the roadmap puts after the gate,
is open, and whether to take it now, its design study first, or to spend
the VM's items above first, is the owner's call.
AW27. The owner's decision after stage 32: the switch of the front end
deferred, the Rust front end kept. Put to the owner on 2026-10-13 with
stage 32's measure (AW26: the check row 1,307.5 million instructions,
the ratio 2.96, within the gate of 3 that AU35 (ii) set for the switch
of the binary's front end to the compiler written in Renyi), the owner's
answer, in the owner's words: the question of self-hosting is put on
hold, this is a point to stop at, the binary keeps the Rust front end
for the time being, and the work goes on to the next step. So: the
switch is deferred, not taken, although its gate is met; renyi check,
parse, format, compile, run and the rest keep the Rust lexer,
parser, checker and emitters; the compiler written in Renyi stays what
it is today, a program of the corpus held equal to the Rust toolchain by
the four judges on every push (decisions W3, W7, Z3), a reference
implementation and the largest test of the VM; and the speed round of
the self-hosting track (stages 25 to 32, AU35 to AW26) closes at the
gate, its binaries and studies kept in the perf lane for whoever reopens
it. The VM's items the profile leaves (the natives' shim at about 110
instructions a call, the code per op, the comparison of two texts) and
the emitters' round for the compile row are not scheduled: they served
the ratio, and the ratio has no consumer now. The next stage is one of
the roadmap's candidates (section 4 of docs/ROADMAP.md: the showcase
application, the WASM target of M6, the language server's completion,
references and rename, the C API of decision A5, the Python binder's
items, the Rust front end's name sets as bits, the emitter's own round),
chosen by the owner; the question is put with this entry.
AW28. The next stages: the WASM target, the language server's
completion, the C API, in that order, and the showcase game in
parallel. The owner's answer on 2026-10-13 to the question AW27 put:
of the roadmap's candidates, the WASM target of M6 first, then the
language server's completion, references and rename, then the C API of
decision A5, in that order; and the showcase application in parallel, by
a subagent (Opus 5.5 at medium effort, the owner's choice of model and
effort): a classic game recreated in Renyi, to be shown on the site and
played in the browser. Four questions were put with the choice and
answered at once. (1) The game: a Doom-style raycasting maze
(Wolfenstein and Doom's 2.5D: a grid map, one ray per screen column,
vertical strips; walls, doors, enemies that are hit or shot, a score),
over a Minecraft-style voxel world, too heavy for the interpreter in
WASM, and over a 2D classic. (2) The display: a new library module,
std.screen; a program declares needs screen and hands each frame's
drawing (columns, rectangles and labels with colours) to the host, which
draws it: the page's canvas in the browser, text on the console under a
native renyi run, with no window library in the binary. (3) The frame
loop: the program writes its own loop, and screen.present suspends the
program and hands control back to the host, which resumes it at the next
frame; the owner chose this over a host-driven frame function, so the
VM must be able to suspend inside a native call and resume later, on
every platform, and the design of that suspension belongs to the WASM
stage's study. (4) The subagent dispatched at once, writing the game's
logic with a text display for local runs, against a contract of three
types in the game's own modules (Colour; Shape with Column,
Rectangle and Label on a logical screen of 320 by 200; Input with
the keys held and the milliseconds elapsed), so that std.screen plugs
in when it exists; it does not run cargo or git, and its work is
reviewed and committed by the main thread. The stages: 33, the WASM
target, its design study first and the study's questions to the owner in
a batch; 34, the showcase game and its page on the site, the subagent's
part first and the integration after stage 33; then the language
server's completion, references and rename, and the C API, each a stage
of its own when it starts.
AW29. The owner's answers after the design study of stage 33: the VM's
own suspension, the whole toolchain in the browser, a C ABI by hand,
cargo features. Asked on 2026-10-13 after the study (the handoff's
section "Stage 33, the WASM target: the design study (session 14)": the
front end's crates build for wasm32-unknown-unknown as they are and
the VM stops in getrandom through ureq, region and libloading
have no wasm backend, the record block's offsets are 64-bit, the clock
panics on the target, the JIT cannot be cut by dropping mod native;
AskUserQuestion, one batch of four). (1) The suspension at
screen.present: the VM's own (recommended), a fifth Interrupt that
keeps the frames, which execute passes through without abandon, the
host resuming with the Input pushed where the primitive's answer would
land and the call recorded then, refused inside a nested loop and on the
interpreter in this stage, over Asyncify (binaryen's rewrite of the
WASM, a tool in the build, the code slower and larger, a mechanism of
one host) and over the VM in a Web Worker blocking on a
SharedArrayBuffer (the cross-origin isolation headers GitHub Pages
cannot set). (2) What the browser runs: the whole toolchain, the owner's
choice over the recommended VM alone on bytecode and over both in turn:
the front end (which builds already), the resolver over a virtual file
system behind its one read function (renyi_package::reads::read_text,
where every file the resolution reads goes through, the manifests looked
for above a program included), the checker and the emitter in the WASM,
so that a page takes sources, checks them with the diagnostics and runs
them: the game's page compiles the game's modules in the browser, and a
playground page lets a visitor edit, check and run a program, the corpus
loadable into it; the WASM two to three times the VM alone, which the
measure records. (3) The toolchain: a C ABI by hand (recommended), a
crate renyi_web of crate-type = ["cdylib"] exporting a dozen plain
functions (the buffers, the files of a virtual file system, check,
compile, run, the output, the frame, resume), the page's script of
about 150 lines written into the site, no tool installed beyond cargo
and the rustup target, over wasm-bindgen with wasm-pack (two tools
on the machine and in CI, the glue generated) and over wasm32-wasip1
with a WASI shim in the page (the road of the server-side WASI of A5,
later). (4) The gating: cargo features of renyi_vm (recommended),
jit, sqlite, http and foreign, on by default and off for the web
crate, the natives of a module left out absent from its table and a
program that needs it refused by the grant before it runs, over stubs
with target cfgs and no features (the wasm build carrying code it
never runs) and over a core crate split out of renyi_vm (the cleanest
cut, the largest move). The stages the answers set: 33a the toolchain
for wasm32 (the features, the record block's offsets as multiples of the
word size, the clock of the VM's own, the virtual file system, the web
crate with the files, check, compile, run and the output, a
program checked and run from a page, the size and the speed measured, CI
building the crate); 33b the suspension (Interrupt::Suspended, the
host in Options, the session and resume, the nested-loop counter,
the recording at the resume, the sandbox's Suspended, tests on the
interpreter); 33c std.screen (the module, the capability screen, the
native, the console host, the game on the library's types); 33d the
pages (the playground and the game, play.js, the Pages workflow),
which closes stage 34 with it; each with its entry. (user)
AW30. Stage 33a, the toolchain for wasm32: the features, the record
block's offsets, the clock, the files provided, the web crate. Built
on 2026-10-13 as decision AW29 set it. (1) The features of renyi_vm,
on by default and off for the web crate: jit (the Cranelift crates,
region, the cache coherence crate and memmap2; native/codegen.rs,
native/image.rs and native/template/, the Jit, the CodeArena and
the compile thread of native/mod.rs, Options::image and
unit_slot), foreign (libloading; natives/foreign.rs and
foreign_abi.rs, the VM's foreign and libraries fields and the
dispatch of a foreign function), http (ureq; natives/http.rs) and
sqlite (rusqlite; natives/sqlite.rs, value::Native::Connection
and its matches); infer.rs, inline.rs and runtime.rs stay, since
the interpreter and the in-place shims use their statuses and helpers,
and without jit a stub Jit whose new answers None carries the
methods and the counters the helpers name, so that vm.rs and
runtime.rs compile unchanged; the natives' table is built by a loop
over the modules' slices with the gated ones appended, and a call to a
function of a module left out crashes as unavailable says. (2) The
record block's offsets (value::layout) are multiples of the word,
WORD = size_of::<usize>(): RC_VALUE two words, RECORD_LEN one,
RECORD_TY two, RECORD_TAG three, RECORD_FIELDS four, the same
bytes on x86-64 and the repr(C) Shape's own on wasm32, where the
study found them apart. (3) The clock of the VM, clock.rs:
now_millis (the budgets, the deadlines, std.time, re-exported by
natives), seed_entropy (the random generator's seed in Vm::new)
and Stopwatch (the runner's timer, the profiler, the server's watch,
the process module's wait), std's on the native targets and on
wasm32-unknown-unknown one import, renyi_host_now_ms, the page's
Date.now(); time.sleep crashes there with the reason, since a page
cannot wait inside a call. (4) The files of a program given as texts,
renyi_package::reads::provide: while they are held, every read of the
resolver comes from them through read_file and a path not among them
is missing, the manifests looked for above a program included;
unchanged reads the same way. (5) The crate crates/renyi_web/
(cdylib and rlib, the VM without its features by its path, since a
member cannot turn a workspace dependency's default features off), a
session per thread holding the files, the arguments and the last
answer's text, and the C ABI: renyi_alloc and renyi_free for the
buffers, renyi_file (a file by its name, the main file and the files
its imports resolve to), renyi_clear, renyi_argument, renyi_check
(the diagnostics as renyi check renders them), renyi_run (what the
program wrote and how it ended), renyi_text with renyi_text_len,
renyi_exit_code and renyi_version; the statuses 0 finished, 1 main
failed, 2 crashed, 3 exited, 4 the program does not check, 5 main
needs a capability the page cannot serve; a run is interpreted under the
grant of what the page serves (console, time, random,
environment), and a main that needs more is refused before the run
with the capability named, as the sandbox of AP1 refuses a call; the
module's stack is 16 MiB (.cargo/config.toml, the render and the
parser recursing on the Rust stack); tools/wasm_check.js drives the
module under node with the import the page provides. (6) CI: the VM
checked without its features on the Linux job, and a wasm job that
lints and builds the web crate for wasm32-unknown-unknown and runs the
hello program and the game's demo through the module under node. Five
unit tests of the web crate (a program checked and run from its texts,
an import among the files given, a program rejected with its
diagnostics, one refused for a capability, a failure, a crash and an
exit told apart), one of the files provided and one of the clock; 424
tests of the whole suite pass, the VM's unit tests without its features
too. The measure: the module 3,027,356 bytes (2.89 MiB), 978,737 gzipped
(0.93 MiB); under node on the owner's machine (Windows wall-clock, a
coarse first measure, node's start of about 0.14 s in every WASM row,
the native rows the development binary's interpreter with the front end,
run --interpret): bench/primes.ry 1.6 to 2.0 s against 1.2,
records 0.29 to 0.32 against 0.15 to 0.21, strings 0.30 against 0.22
to 0.24, json_round_trip 0.27 against 0.33 to 0.39; the game's trace
of 237 frames 0.34 to 0.37 s against 0.22 to 0.23, its demo 0.37 to
0.64 s with the eleven modules compiled in the module: the interpreter
in WASM runs at about two thirds of its native speed on integer loops
and at parity on the allocating programs, and a frame of the game costs
about a millisecond, a sixteenth of what a frame at 60 a second allows.
Next: 33b, the suspension.
AW31. Stage 33b, the suspension: Interrupt::Suspended, the host in
Options, resume, std.screen. Built on 2026-10-13 as decision
AW29 set it: a program's frame loop hands each frame to the host, and
when the host cannot answer at once the VM suspends inside the call and
the host resumes it later; with it the library module the mechanism
serves, std.screen, and its capability. (1) The mechanism. A fifth
interrupt, Interrupt::Suspended (vm.rs): a native returns it when
the host answers later; run_frames leaves as for any interrupt, the
pc past the call written back and the arguments off the stack; execute
passes it through without abandon, so the frames, the stack and the
handlers stay as they are; the boundary (call_primitive) keeps what
the call needs to be noted (Suspension: the function, the effect, the
encoded arguments, the start time, the origins, the arguments as
--explain shows them, and the entry execute was running for) and
notes nothing yet. Vm::resume(input) builds the Input record, notes
the call as the boundary notes a live one (note_call, now shared by
both: the narration of --explain and the recording's entry, the
duration measured to the resume), pushes the record where the
primitive's answer would have landed and runs execute from the top
frame at its pc; its result is run_main's, or the next suspension;
Vm::is_suspended says whether a resume is due. Under a replay the
boundary answers present from the recording before the native runs,
so a replay never asks the host and never suspends. The host is
Options::screen, an Rc<RefCell<dyn Screen>> shared between the VM
and whoever drives it (screen.rs: Screen::present(frame) ->
Answer::Now(input) | Later and Screen::suspends(); the frame as
plain Rust, a Vec<Shape> of Column, Rectangle and Label with a
Colour, the input as Input); the runner, the sandbox and the web
crate hand none unless given one. (2) Three rules. A suspension can be
resumed only from the run's own loop: execute counts the loops in
progress on the Rust stack (nesting), and a primitive may suspend
only at depth one, with no generated code on the stack
(native_state.depth) and no suspension pending (can_suspend);
inside a nested loop (a module constant, a comparison, a text
conversion, a decode, the handler of server.serve, the one library
callback) a host that answers later crashes the run with a message that
says so. A run whose host may answer later stays on the interpreter:
Vm::new treats screen.suspends() as it treats --interpret, since
the interpreter alone resumes a frame at its pc (the generated code's
entries are a code object's start and its loop headers; handing every
compiled frame back at a call is work the records of AW24 prepare and no
path does), while a host that always answers at once (the console host
of 33c) leaves the run its machine code. The call is recorded in full,
like every effect: the frame as its argument (the list of shapes as
JSON), the input as its outcome, the duration to the resume; a summary
of the frame was weighed and declined, because a replay matches a call
by its arguments and a replays test of a game should see a changed
frame. (3) The holders. run_main, run_program and run_tests run
to the end of main in one piece: a host that answers later under them
ends the run with a crash that says what drives a suspension
(Vm::run_main and Vm::resume, as the VM's tests do and the web
crate's session of 33d will). Sandbox::set_screen gives a sandbox a
host, and a call runs in one piece too: a host that answers later ends
it with CallError::Crashed saying so; the study's Suspended with a
resume on the sandbox would need the VM kept across calls, which
Sandbox::call does not do (a VM per call), so the session that keeps
one is the web crate's, stage 33d, and the web crate maps the interrupt
to a crash until then. (4) std.screen (library/std/screen.ry and
the checker's copy, LIBRARY; section 16 of the stdlib sketch, the
module among the core modules of its rule 3): Colour (three Integer
channels, clamped to 0 to 255 by the host), Shape (Column(screen_x,
top, bottom, colour), Rectangle(screen_x, screen_y, width, height,
colour), Label(screen_x, screen_y, text, colour): the game's contract
of AW28 field for field, screen_x and screen_y because a
single-letter name is rejected), Input (the six keys and
elapsed_ms), the three can ToText (derived, as the VM derives it
for a library type); present(frame: List of Shape) returns Input
needs screen; width() and height(), 320 and 200, pure functions
since a declaration file holds no constant with a value. The
capability screen is a root of the tree (effects.rs,
compiler/effects.ry and the module list of compiler/project.ry,
decision AD1), takes no scope and no budget; the reference's section
11, the cheat sheet (its renyi tools sentence trimmed to stay under
the budget, 2998 tokens), the syntax sketch, 06-runtime-guarantees.md,
extensions.md, the starter skill, the README and the VS Code grammar
(which also gains python, missing there) list it. The native
(natives/screen.rs) reads the list of variants by tag and field
position into the frame, asks the host and builds the Input record
through library_record; without a host the call crashes ("the screen
is not available here"), which the console host of 33c replaces for
renyi run. (5) Tests. crates/renyi_vm/tests/screen.rs, seven: a
host that answers at once drives a frame loop (with the JIT); a host
that answers later suspends the run at every frame and resume
continues it, the recording holding the three present calls with the
frame as their argument and the input as their outcome among the
prints, in order; a replay of that recording runs without asking the
host; a run without a host crashes at the call; a host that answers
later under the runner is a crash that says so; the size and every
shape cross the boundary with the colours clamped; a suspension inside
the handler of server.serve crashes with the message naming the
place. crates/renyi/tests/sandbox.rs, one more: a sandbox hands the
frames to its screen, which must answer at once. The conformance suite:
a frame loop that needs the screen checks clean (screen_needs.ry, a
check case). The selfhost judges parse, check and compile the new
declaration file and the conformance program as the Rust toolchain
does; the library test counts sixteen modules. (6) The measure (the
wasm lane's measure_33b/: 2,000 frames of 320 columns and a label,
Windows wall-clock, coarse, three rounds): a frame suspended and
resumed through a host that answers later costs 470 to 497 microseconds on
the interpreter against 409 to 497 for the same frame answered at once on the
interpreter and 402 to 423 with the machine code, the frame's own cost (the
320 columns built, converted and encoded) in every row: the suspension
itself is below the noise of the measure. The module for wasm32
3,038,187 bytes (2.90 MiB), 982,441 gzipped (0.94 MiB),
hello and the game's demo under node as at 33a. The whole suite,
432 tests, passes; clippy is clean natively and for wasm32; the VM
without its features checks.
Why: the owner chose the VM's own suspension over Asyncify and a worker
(AW29 (1)), and this is the smallest form of it: one interrupt passed
through one function, every other path (abandon, the hand-backs, the
replay) as it was; the host behind a trait keeps the VM free of any
knowledge of a terminal or a browser; the call noted at the resume keeps
renyi record and replays whole for a session; and the three rules
say exactly where a suspension cannot happen (a nested loop, a compiled
frame, a holder that runs in one piece) instead of letting one corrupt
what it cannot resume. Next: 33c, the console host and the game on the
library's types.
AW32. Stage 33c, the console host and the game on the library's
types. Built on 2026-10-13 as decision AW29 set it. (1) The console
host, ConsoleScreen in screen.rs of the VM: a Screen over two
streams that answers every frame at once, so a run under it keeps its
machine code. A frame is drawn as text into a grid of characters, each
cell the brightness of the colour under the cell's middle (the ten
characters from dark to bright by the luma weights of Rec. 601, the
sampling of the game's own text_view.ry: a column or a rectangle
covers the cells whose middle lies in it, a label is written from its
cell to the right and clipped at the row's end); then a line is read,
whose letters are the keys held, w forward, s backward, a turn
left, d turn right, f fire, q quit, the end of the input being
quit; the elapsed time is the real one since the previous frame
(clock::Stopwatch). ConsoleScreen::standard() is the host over the
process's own streams at the terminal's size, read from the variables
COLUMNS and LINES when they are set and 80 by 24 otherwise, one row
kept for the prompt: no terminal library, as AW28 (2) asked, and the
size a variable away when the default is wrong. renyi run and
record give it to a program whose main needs screen (grants, as
the notes for foreign and python are chosen), renyi test to every
test (a replays test never asks it); serve, the MCP server and the
sandbox hand none, where a present crashes with the reason as before.
ConsoleScreen::text_of is the grid alone, for the tests. (2) The game
on the library's types: shapes.ry keeps the screen's size as two
constants built from screen.width() and screen.height() (a module
constant from a pure library call, so view.ry and text_view.ry
read them as before, and the generated code sees a literal) and
shaded; input.ry keeps idle and repeated over the Input of
std.screen; game.ry, player.ry, view.ry, text_view.ry and
raycaster.ry import the types from std.screen; raycaster.ry
gains play, the real-time loop (screen.present(view.render(state))
stepping the game until the status leaves Playing, the final score
printed), and main needs screen with it, so renyi run
showcase/raycaster/raycaster.ry play plays the maze at the terminal;
demo, trace and steps are as they were, the 94 examples and tests
pass and the demo ends as before. The page's grant in the web crate
gains screen (the page is its host at 33d; a present in the
browser crashes with the reason until then), so the game's main
passes the page's refusal and the demo runs through the module as CI
checks. The README of the game names the contract as std.screen and
the browser's part as the page. (3) The reference's section 11 gains
the note on screen beside those on foreign and python: the frame
to the host, the console host of the commands and its keys, the
suspension and the recording, the callback that cannot wait. (4) Tests:
crates/renyi_vm/tests/screen.rs one more, eight: the console host's
grid on the text view's own case and a frame loop driven by three
lines and the end of the input, the frames and the prompt on the same
stream as the program's prints. The game's 94 examples and tests, CI's
strict check, format check and tests of the showcase, and the demo
through the WASM module. The whole suite, 433 tests, the
conformance suite 56 of 56; clippy clean natively and for wasm32; the
module 3,038,512 bytes (2.90 MiB), 982,497 gzipped
(0.94 MiB).
Why: the console host is the second client of the mechanism and the
one that needs no page, so renyi run of the game works today and the
VM's tests cover the host's grid and keys without a terminal; the
sampling is the game's own so that the terminal and the text view
agree; the size from two variables keeps the binary free of a terminal
library; the constants over width() and height() keep the game's
other modules untouched; and screen in the page's grant now, with the
crash until 33d, keeps CI's demo run honest about what the page serves.
Next: 33d, the pages.
AW33. Stage 33d, the pages. Built on 2026-10-13, the last stage of
the WASM target as decision AW29 set it, which closes stages 33 and 34.
(1) The web crate's session across a suspension: the page is the host
of std.screen, PageScreen in crates/renyi_web/src/lib.rs, which
keeps the frame and answers Later, so a run that presents suspends
inside the call (AW31). A suspended run lives on as Live: the VM, the
program it borrows (boxed and held by a raw pointer, freed by Drop
after the VM: Vm borrows its program for its lifetime and a page's
loop must return to the browser between frames), the log and the host.
run answers the outcome and the run, resume continues it with an
Input, and settle maps the result to a status, the sixth being
SUSPENDED, 6, the text being what the program wrote during that call
(the log drained per call, so a frame loop that prints does not grow
the answer). The frame crosses the C ABI as text, one shape per line
(column <x> <top> <bottom> <r> <g> <b>, rectangle <x> <y> <width>
<height> <r> <g> <b>, label <x> <y> <r> <g> <b> <text>, a line break
in a label's text made a space), read through renyi_frame and
renyi_frame_len; renyi_resume takes the six keys as 0 or 1 and the
milliseconds elapsed as a 32-bit integer and answers as renyi_run
does; a renyi_resume with no run suspended is a crash that says so;
renyi_run and renyi_clear abandon a suspended run. (2) The page:
docs/play.md, "Play", in the Learn group of the site with a lead and
the layout of How it works, two sections, the maze and the playground.
docs/assets/play.js loads the module from assets/renyi_web.wasm
(instantiateStreaming when the server says application/wasm, the
bytes otherwise) and the game's eleven sources from assets/raycaster/
by the index tools/site.py writes with the main file first; draws a
frame on a canvas of 640 by 400 at the scale of 2 (a column one
logical pixel wide, a label in an 8-pixel monospace); reads the keys on
the canvas (W and S or the arrows, A and D or the arrows, Space or F,
Escape or Q, a key held until released, every key released when the
canvas loses the focus) and drives the run from
requestAnimationFrame, the elapsed time clamped to 100 ms so that a
tab in the background does not step the game by minutes; a line under
the canvas gives the frames of the last second and the time per frame
inside the VM. The playground is a text area with a program, Check and
Run, arguments and an output; the editor's text is the session's one
file, named after its module; a program that presents frames plays on
the same canvas; a main that needs more than the page serves is
refused before it runs with the capability named, as the sandbox
refuses a call. Without the script the page says what it needs. (3)
The site: tools/site.py takes --module <renyi_web.wasm> and copies
the page's script, the game's sources with their index and the module
under assets/ (play_files), the one exception to "no request leaves
a page": the play page loads its own files from the site; the front
page's links gain Play. The Pages workflow installs the Rust toolchain
with the wasm32 target and builds the module before the site. (4)
tools/wasm_check.js drives a suspended run as the page does:
--script <moves> in the game's own notation, 64 ms a frame, then
quit until the run ends, with the frames, the shapes of the first and
the time per frame on standard error; CI's wasm job runs the game's
play mode with the demo's moves and checks that it ends as the demo
does. (5) Tests: crates/renyi_web three more, eight: a frame loop
suspended at every frame and resumed with the input (the text per
call, the frame's text, fire and elapsed_ms reaching the program,
quit ending it), a label's text on one line, and the C ABI driving a
suspended run (a resume with none, a run abandoned by the next and by
renyi_clear). The whole suite 436 tests, the conformance suite 56 of
56, clippy clean natively and for wasm32; the module 3,049,093 bytes
(2.91 MiB), 986,578 gzipped (0.94 MiB). (6) The measure: under node the
demo's 237 frames through play at 4.86 to 5.56 ms a frame in the
module (three runs; the first frame is 329 shapes); in a headless
Chrome 155 on the owner's machine (the wasm lane's
measure_33d/measure.js over the DevTools protocol against the built
site served by python -m http.server, the forward key held), 60
frames a second at 3.98 to 5.51 ms a frame in the VM over two runs of
six seconds, the game quit by Escape with its final score and played
again after a run of the playground, the playground's program run, a
main that needs filesystem.read checked clean and refused at the
run, a typo diagnosed with its fix, no console error; all wall-clock,
coarse.
Why: the page is the third host of the mechanism and the one AW28
asked for, so the game is played in the browser without a line of the
game changed, as its README promised; the frame as text keeps the ABI
plain and readable under node, and a frame of 329 shapes is a few
kilobytes a tick, which the measure shows costs nothing visible beside
the VM's 4 ms; the program boxed behind a raw pointer is the stage's
one unsafe construct beyond the ABI's own pointer reads, documented,
because Vm borrows its program and the page's loop must return
between frames; the text drained per call keeps a printing loop from
growing the answer; the module copied by the site script rather than
fetched from CI's job keeps the Pages workflow self-contained; and the
rate line on the page is the measure AW28 asked for, visible to anyone
who plays. Stage 33 is done and stage 34 with it; the language
server's completion, references and rename are next (AW28's order),
then the C API.
AW34. The owner's answers after the design study of stage 35: the
three sub-stages in order, the locals recorded by both checkers, the
bare completion with the names and the statement words, signature help
and workspace symbols included. Asked on 2026-10-13 after the study
(the handoff's section "Stage 35, the language server's completion,
references and rename: the design study (session 14)"; AskUserQuestion,
one batch of four), every answer the recommended option. (1) The split
and the order: 35a references and rename of declarations, 35b the
locals (the checker's record, then references, rename and the names in
scope for them), 35c completion; each built, tested and committed in
turn. (2) The locals: the checker records every use of a binding as a
reference, Target::Local with the binding's declaration span, in
crates/renyi_check/src/check.rs and the same in compiler/bodies.ry;
the judges compare the diagnostics, which do not print the references,
so the two records are kept equal by hand, as the transcription is.
(3) The completion at a bare position: the bindings of the function
declared before the position, the module's functions, constants and
types, the imports' namespaces and exposed names, the prelude's
functions that are not methods, and the words that start a statement
as keywords, the locals first. (4) The extras:
textDocument/signatureHelp and workspace/symbol join 35c. Why: the
order puts the shared record (the declarations' references) first and
the feature with the most judgment in it (completion) last; the
checker is the one place that knows the scopes, so recording there
keeps the server free of a second scoping; the statement words
complete what a reader types most; the two extras cost little on the
signatures and the map the server already has. (user)
AW35. The DOOM look: stage 36, opened in parallel with stage 35, the
art from Freedoom, Strip, Picture and play in std.screen, a
page of its own with sound. The owner, shown the play page of AW33
on 2026-10-13, found the game crude ("游戏看着太粗糙了"), floated a
separate front end on a host such as Vercel, and asked for the showcase
to be a DOOM replica in the literal sense ("直接就按字面意义复刻
DOOM"). The diagnosis given: the look is the renderer's, not the
host's; the page and the module are served by GitHub Pages already
(renyi-lang.org/play.html answered 200 and the module
application/wasm, checked that day), and a second host would draw the
same flat-colour columns shaded by distance, the same two-tone figures
and the same eight-pixel labels; what DOOM has is textured walls,
animated sprites, a weapon in the foreground, a status bar and sound.
The four answers (AskUserQuestion, one batch of four; every answer the
recommended option): (1) now, in parallel: a subagent (Opus 5.5, medium
effort, subscription quota, as for the game's first version, AW28)
rewrites the game's rendering, animation, weapon and status bar on the
extended contract, while this session extends std.screen, the two
hosts and the page; stage 35 follows. (2) The art from Freedoom
(github.com/freedoom/freedoom, the 3-clause BSD license of its
COPYING.adoc, checked that day: the sprites, the wall patches, the
flats and the graphics are PNG files of a DeuTex tree, the sounds WAV
files, with DOOM's lump names; the demon sarg*, the shotgun shtg*
and shtf*, the status bar stbar, stfst*, stfouch*, stfdead0,
sttnum*, sttprcnt, stysnum*, the title picture, the sounds
dsshotgn, dssgtsit, dssgtatk, dssgtdth, dsplpain, dspldeth,
dsdoropn, dsdorcls among them); the copyright notice and the
license kept beside the art in the repository, the README naming the
source. (3) std.screen gains two shapes the host draws from named
images and one call: Strip(screen_x, top, bottom, image, column,
shade), one column of the image stretched between two rows, its
colours scaled by the shade in percent, the column taken modulo the
image's width; Picture(screen_x, screen_y, width, height, image,
shade), the image stretched to a size at a place; play(sound) needs
screen, the named sound played once by a host that can. The names are
the host's to resolve: the page to the files served with the game, the
terminal to nothing (a strip or a picture is a block of its shade's
glyph there, a sound is ignored). Floors and ceilings stay flat shaded
bands, so the VM's work stays one shape per column and the frame rate
of AW33 holds; the per-pixel work is the host's. The owner declined a
Floor shape that would hand the camera to the host (rendering math
out of Renyi) and the game drawing pixels itself (sixty thousand shapes
a frame, which the interpreter cannot give at 60 frames a second). (4)
A page of its own on the site, full width, with a title screen and the
keys, the play page keeping the playground and linking to it; the
sounds played by the page through play. The page and the game are
named by the game, not by the trademark. The stages: 36a the contract,
the VM, the console host and the web crate; 36b the art (a script that
takes the chosen files from Freedoom, their sizes as constants for the
game, the notice); 36c the game, the subagent's part; 36d the page and
the measure. Why: the showcase is the first thing a visitor plays, and
a Doom-style game that looks like 1992 says more about the language
than one that looks like a sketch; Freedoom gives the look at no
license cost; the contract stays a list of shapes, each a few
integers and a name, so recording, replay and the console host keep
working and the game stays a pure function of its state. (user)
AW36. The owner's answers on release 0.2, the marketplaces, GitHub's
front and the announcements; GitHub's recognition of .ry waits for
Linguist's usage bar. Asked on 2026-10-13 (AskUserQuestion, one batch
of four) after the owner asked what remains, and how the release, the
promotion and the presence on GitHub and in VS Code are completed.
(1) Release 0.2 follows stage 35, not stage 36 (the owner's choice over
the recommended release at the end of stage 36): the language server's
completion, references and rename go into it. (2) The VS Code extension
is published to the Visual Studio Marketplace and to Open VSX from a
publisher renyi-lang the owner creates (a Microsoft account with a
personal access token of Azure DevOps scoped to the Marketplace; an
Eclipse account for Open VSX; neither token enters the repository); a
session prepares the commands and the extension's page, the owner runs
the publish (docs/RELEASE.md section 6). (3) The repository's front on
GitHub was set the same day with gh repo edit: the description (the
one line of docs/design/08-positioning.md section 6), the homepage
renyi-lang.org and fifteen topics (programming-language, ai-agents,
agentic, mcp, mcp-server, claude-code, codex, capability-based-security,
effect-system, reproducibility, sandbox, rust, webassembly,
language-server, vscode-extension); the social preview image of
decision AV1 is the owner's to upload. (4) The announcements go to Show
HN and lobste.rs, to the MCP directories and the awesome lists (the
official MCP registry, Smithery, awesome-mcp-servers) and to the owner's
X and LinkedIn; a session writes the texts from section 6 of the
positioning document with the game's page as the hook, at release 0.2,
and the owner posts them. Also asked that day: whether GitHub can
recognise .ry as a language. That is Linguist's
(github-linguist/linguist): a language is added by a pull request
only once GitHub's search finds at least 2,000 files of the extension
indexed in the last year, forks excluded, spread across repositories
and not mostly the language's owner's (its CONTRIBUTING.md, read that
day; .ry and .renyi are taken by no language of its table), so the
pull request waits for the use, and its materials are in the
repository already: the TextMate grammar
editors/vscode/syntaxes/renyi.tmLanguage.json with the scope
source.renyi under the Apache-2.0 license, and the corpus as samples
(docs/RELEASE.md section 6 says what the pull request carries). Until
then GitHub shows a .ry file as plain text and counts no Renyi in a
repository's language bar, and no .gitattributes changes that:
linguist-language names only a language of the table. Why: the
release waits for the extension's completion because the extension is
what a reviewer sees first; the publishers are accounts, which are the
owner's; the front costs nothing and is read before the README; the
channels are where the first users are (decision AH1); Linguist's bar
is theirs to set. (user)
AW37. Stage 36 built: the contract, the art, the game and its page;
the DOOM look measured in the browser. 2026-10-13, the four parts of
AW35. 36a (commit 79ad76c): Strip, Picture and play in
std.screen as AW35 drew them, the VM's shapes and Screen::play, the
console host's blocks of the shade's glyph, the web crate's strip and
picture lines and the sounds of a call through renyi_sounds; the
cheat sheet at its budget exactly. Its CI run was red: the game's text
view matched the shapes without the new two, which the gates of 33b do
not check (they leave showcase/ to CI); 36b made it exhaustive. 36b
(commit c868686): tools/freedoom_art.py, the 201 files under
showcase/raycaster/art/ (472 KB) with the license and a README of
their sources, and art.ry. 36c, the subagent's (Opus 5.5, medium
effort, 37 minutes, 134 tool calls): the game rewritten on the contract
in sixteen modules of 3,045 lines: ten tile types with a texture each
(level.ry); the camera once per frame and the DDA on plain counters
(raycast.ry, which took the frame from 7 to 9 ms to about 5 in the
module); doors that rise in 520 ms, stay and come down (level.ry,
player.ry, game.ry); demons that sleep until they see the player,
shout, chase, bite, flinch and die, a sound per event (enemies.ry;
sprites.ry the frame A to N from the state and the rotation 1 to 8
from the angle in integers, 6 to 8 the images of 2 to 4 mirrored); the
shotgun on a fresh pull, again after 940 ms, 50 shells (weapon.ry);
the large font laid out as pictures (font.ry); the status bar at the
original's positions with the face by health (hud.ry); the title, the
play and the end screens, each frame's sounds in the state (game.ry,
view.ry); play playing them after present (raycaster.ry).
Measured: 192 examples and tests pass, check --strict prints nothing,
the layout is canonical; the demo escapes at frame 279 with the score
1,120 (CI's expected lines updated, its play script with a fire first
to leave the title); under node 306 frames, 38 shapes in the first (the
title), 3.85 to 4.46 ms a frame in the module over three runs; the
busiest frame 698 shapes by the subagent's count, a rising door drawn
with the wall behind it in every column. 36d: the game's page
docs/game.md (the layout game: the canvas as wide as the window and
no taller than it, full screen on request, sound on with a switch, the
keys on the window while the game runs, the program's last line and the
rate under the canvas), the play page kept for the playground with a
poster linking to the game and a screen under its output;
docs/assets/play.js draws a strip as one column of an image through
drawImage and a picture stretched, keeps each image in sixteen shades
made once with source-atop so that a sprite's transparent pixels stay
transparent, plays the sounds through an audio context made at the
first click, and loads the art six files at a time with two retries
(two hundred fetches at once overflowed the listen queue of five of
python -m http.server, which a local build is seen with; the lane's
measure serves with a node script instead); tools/site.py copies the
art with an index and the license. In a headless Chrome 155 on the
owner's Windows machine (GPU off, coarse): 55 to 60 frames a second at
3.0 to 3.8 ms a frame in the VM, no console error or warning, the title
screen, the maze and the status bar drawn as the lane's screenshots
show. Left as it is, for the owner to ask for: a rising door is drawn
squashed, a Strip stretching the whole column (a source range on
Strip would draw it sliding, a contract change); the kills show on
the end screen only; no pain flash; the shotgun's sway stops where it
was; dsitemup, wall62_1, sttminus and stfgod0 are in the art
unused. The lesson of 33d repeated: a heading with the id game
beside the canvas broke the play page again, renamed the-game.
Next: 35a, the references and the rename of declarations.
AW38. Stage 35a built: references and rename of declarations in the
language server. 2026-10-13, the first stage of AW34's order. renyi
lsp answers textDocument/references, textDocument/prepareRename and
textDocument/rename (crates/renyi/src/lsp/refer.rs; the capabilities
referencesProvider and renameProvider with prepareProvider). What a
position names, target_at in lsp/describe.rs: the innermost of the
bodies' references the checker recorded whose target has a name (a
function, an ability's method, a constant, a type, a variant, an
ability; the VM's annotations left aside), else a type or an ability
named in a signature (the parameters, the result, the failures and the
constraints of a function; the fields, the base and the derives of a
type; the requirements of an ability and its methods' signatures; the
head, the target, the constraints and the methods' signatures of an
implementation; a constant's type: renyi_index::signature_references,
the collectors the map's drafts had, over every item of a module as a
public function), else a name an import exposes, else the declaration
whose own name is there; hover and definition answer at those places too
now. The occurrences of a definition are those references across the
modules the workspace owns (its own files and its dependencies'; a
library definition's occurrences are the workspace's alone) and its
declaration, which references lists when the request asks
(includeDeclaration). A method is renamed with its family: an
ability's method and the method of every implementation of the ability
share a name, a call on a value of a concrete type resolving to the
implementation's function and one on a constrained type parameter to
the ability's method, so the family is the ability's method with every
implementation's method of that name, found from either end. A rename is
refused as a response error (-32803, the protocol's RequestFailed)
whose message the editor shows: when a member of the family is declared
in the library or in a dependency (Workspace::file_of none, or the
file tagged with a package); when the new name is not one word of the
class (lowercase for a function, a method or a constant, capitalized for
a type, a variant or an ability) or is a reserved word of reference
section 17, which the lexer decides as it does for a program; and when
the project checked again with the edits applied (Workspace::sources
gives every file as the check read it, the edits go into copies,
check_project_in runs on them) has in some file more errors of a code
than it has now, the checker's message with its line naming the reason
("square is a function of this module" for a function renamed to the
name of its own parameter): the rules of the language, not a second
scoping in the server. The edits are a WorkspaceEdit with a TextEdit
per occurrence, grouped by file; prepareRename answers the name's
range and the name, null where nothing is named, the refusal where the
family cannot be renamed. The VS Code client needs no change. Tested in
crates/renyi/tests/lsp.rs on the two-file project grown by an ability
and its implementation: the references of a function from its call
(the declaration and the call), of a type from its declaration (the
parameter's type, the implementation's target, the exposing import, the
construction), of a library function (its calls alone); prepareRename
on a method call; the rename of the method through the ability, the
implementation and the call; the four refusals (the parameter's
shadowing found by the check after, a reserved word, the wrong class, a
library function); hover on a type in a signature; and refer.rs's own
tests of the name rule and the edits. A field is not a target (a field
is read by name on a value the checker typed, no reference recorded), so
a field has no references and no rename; the locals are 35b. Next: 35b,
the locals recorded as references by both checkers.
AW39. Stage 35b built: the locals recorded as references by both
checkers; references, definition and rename of a binding in the
language server; the Renyi checker's references kept per body.
2026-10-13, the second stage of AW34's order. A use of a binding is a
reference now: crates/renyi_check/src/check.rs records
Target::Local(declared), the span of the binding's declaration (a
parameter's name, self among them, a let's, a pattern's, a loop's, a
query's), at every name that resolves to a binding (infer_name), at
the name a change statement updates, at self (the span of the
expression) and at a call of a binding of function type; the checker's
other lookups of a binding are tests (whether a receiver is a mutable
binding, whether a namespace is a binding) whose expression is inferred
through infer_name too. compiler/bodies.ry records
LocalTarget(declared:) at the same four places (infer_name,
check_set, infer_self, call_by_name); the judges compare the
diagnostics, which do not print the references, so the two records are
held equal by reading, as the other targets are. The consumers of
Target: the map's edges leave the kind out (a binding's use is no edge
of the map), both compilers pick their targets at a span by kind and
passed every other kind over already (the loops' _ => {} and
otherwise continue arms), and the server's describe gives a local no
module, no name and no declaration item. In the server: target_at
finds a binding at its declaration too (local_declared_at, the Local
reference whose declared span holds the position); the occurrences of a
binding are its uses and its declaration within the module
(local_occurrences), so references lists them and rename edits
them; definition from a use goes to the declaration; hover on a binding
stays unanswered (the type the checker noted at the use, Target::Typed,
would give it; not this stage). A rename of a binding is refused for
self ("self cannot be renamed: it names the receiver of a method"),
for a new name that is not one lowercase word or is reserved
(check_name, the class of a local being lowercase), and when the
project checked with the edits applied gains an error, which covers a
new name the function binds, imports or declares ("main is a function
of this module" for a local renamed to the module's function).
The cost of the record, measured in the perf lane on the Linux release
build under callgrind, the same input for every build, the base's
compiler/bodies.ry (82566d4). The first build raised the Renyi
checker's check row from 1,310.1 to 1,469.3 M instructions (+12.2%)
while the Rust front end's check went from 173.8 to 175.9 M (+1.2%),
the rise all in copies (memcpy +64.5 M at the same call count,
release_last +34.0 M, clone +26.4 M, the generated code +3.9 M). A
probe in the VM found the mechanism (the in-place append noting the
length of a list it had to copy, the interpreter printing the running
code object and its callers; probe_list_copy.py, applied for the
measure and reverted): record appended to the module's references
list through a checker its caller still held, 1,196 times in the run
against 1,060 in the base (632 from call_known under
infer_method_call, 292 from record_variant_target, 99 from
infer_name, 66 from check_set, the rest smaller), and an append on
a shared list copies the whole list (list_append_in_place, decision
AU54), so each of those copied the module's references so far:
925,813 elements in the base, 3,314,818 with the locals recorded, the
lists three times longer. A rewrite of record as a change statement
(the shape of decision AU11) measured the same, 1,469.6 M, the return
... with form being in place already. The remedy is in the checker's
shape: the references are kept per body (body_references, which
record appends to) and joined to the module's list once the body is
finished (finish_body), so that a checker held twice at a record
copies the body's references, not the module's: 20,733 elements in
1,756 copies after the change, the order of the references and the
judges unchanged. The check row with it: 1,310.1 to 1,272.0 M
(-2.9% against the base), the Rust row 173.8 to
176.1 M (+1.3%). The four callers that hold a checker
across a record are left as they are, a cut for a later round
(probe_list_copy.py finds them). Tested in
crates/renyi_check/tests/rules.rs (the uses of a parameter and of a
let, by span) and over pipes in crates/renyi/tests/lsp.rs (the
references of a local from a use, definition from a use, the rename
from the declaration editing the three places, the refusals of main
and of self, prepareRename on a use). Next, by the owner's call of
2026-10-13 after this stage: the adaptation of the map for retrieval by
embedding ("find a way to fit the RAG side"), its design study first,
then 35c, completion with signature help and workspace symbols (AW34
(3) and (4)), then release 0.2 (AW36).
AW40. The owner's answers on stage 37, the map for retrieval by
embedding. 2026-10-13, after the study (the handoff's section "Stage
37, the map for retrieval by embedding: the design study (session 14)"),
every answer the recommended option. (1) The chunk's text is settled by
a prototype that measures the three candidates on a query set (the
canonical source alone; a header from the record, the qualified name,
the kind, the signature, the purpose, the tags, the transitive effects
and the module's purpose, with the source; the header, the source and
the purposes of what the definition calls), hit@1 and hit@5 with one
embedding model, and the best is built. (2) The export lives in renyi
index --chunks, JSON Lines with a header line, and in an MCP tool
chunks with the same answer. (3) A chunk's id is the hash of the
embedded text, so that the host re-embeds exactly what changed, with
the map's id and text_hash in the metadata for the semantic
identity. (4) Module chunks and test chunks are part of 37b; the
language's documents as chunks (--language: the cheat sheet, the
reference's sections, the library's declarations) and an example
pipeline in starter/ are 37c. The stages: 37a the prototype and the
measure (tools/chunks_prototype.py over index --json and the
sources, the query set under tests/retrieval/, the three texts
measured, the text settled, the numbers in its decision entry); 37b the
export in Rust (renyi_index::chunks, index --chunks, the MCP tool,
the tests of the ids' stability and of the shape, 05-agent-tooling.md,
positioning 2.3, the starter's README, the MCP table); 37c the extras.
No model and no network in the toolchain: Renyi writes, the host
embeds. 35c follows stage 37; release 0.2 follows stage 35 (AW36).
AW41. Stage 37a built: the prototype of the chunks and the measure of
their text. 2026-10-13. tools/chunks_prototype.py <path> --text
source|header|hops [--renyi <binary>] [--out <file>] writes the map's
definitions as JSON Lines, one chunk per definition after a header line
(the project, the revision, the toolchain, the text, the count): id
the SHA-256 of the text, text one of three candidates, metadata the
qualified name, the map's id as map_id, text_hash, module,
package, kind, public, signature, purpose, the transitive effects and
failures, calls, uses, tested_by, see_also, whether tested and the
location. The texts: source, the definition's canonical source;
header, a header (the kind and the qualified name, the signature, the
purpose, the tags, the transitive effects and failures, the module's
purpose) and then the source; hops, the header, the source and the
purposes of the project definitions the body calls.
tools/chunks_measure.py --queries tests/retrieval/queries.json [--model
<name>] [--bm25] <chunks.jsonl>... ranks one index of chunks for every
query by the cosine of normalized embeddings (sentence_transformers, a
model from the local cache under HF_HUB_OFFLINE=1) and by BM25 over
lower-cased alphanumeric tokens, and prints hit@1, hit@5 and the mean
reciprocal rank in all and per project. The query set,
tests/retrieval/queries.json: forty-five questions, twenty-five on
examples/ and twenty on compiler/, paraphrasing the purposes, a few
quoting code, each with its target. The measure, the two projects'
chunks in one index of 1,747 (the corpus 171, the compiler 1,576): with
BAAI/bge-m3 (8,192 tokens, nothing truncated) hit@1 64.4%, 68.9% and
71.1% for source, header and hops, hit@5 86.7%, 91.1% and 91.1%, MRR
0.746, 0.782 and 0.788; with sentence-transformers/all-MiniLM-L6-v2
(256 tokens, the longer chunks truncated after their head) hit@1 48.9%,
53.3% and 48.9%, hit@5 77.8%, 84.4% and 82.2%, MRR 0.640, 0.655 and
0.629; BM25 hit@1 60.0%, 71.1% and 62.2%, hit@5 84.4%, 86.7% and 84.4%,
MRR 0.724, 0.786 and 0.745. The compiler's queries are the hard ones
(bge-m3 on the header text hit@1 60.0% against the corpus's 76.0%;
MiniLM 20.0% and 80.0%). The text settled: header, which wins on every
measure of the small model and of BM25 and ties the large model's hit@5,
where hops has one query more at hit@1 (32 against 31) and 0.006 more
MRR, for chunks a fifth longer (1.19 of the header's text in all) that
change whenever a callee's purpose does; the header with the source is
what 37b exports, the hop is left out. Noted beside it: BM25 over the
header text matches the large model on hit@1 (71.1% against 68.9%) and
beats the small one, the purposes carrying the words a question uses, so
a host without an embedding model retrieves well from the same chunks
lexically. The chunks' sizes with the header: the corpus median 476
characters, the 90th percentile 982, the longest 1,653; the compiler
676, 1,636 and 3,596; in the small model's tokens the compiler's median
176, the 90th percentile 421, the longest 1,149, and 479 of its 1,576
chunks (30.4%) and 18 of the corpus's 171 are over its 256, so its
measure is of the chunks' heads. The six chunk files and the two measure
logs are the wasm lane's rag_37a/. Next: 37b, the export in Rust
(renyi_index::chunks, renyi index --chunks, the MCP tool chunks,
module chunks beside the definitions', the tests of the ids and of the
shape, the documents).
AW42. Stage 37b built: the chunks in the toolchain. 2026-10-13.
renyi_index::chunks (crates/renyi_index/src/chunks.rs) projects a map
and the canonical files it was built from into one chunk per module and
per definition, in the map's order. A definition's text is the header of
AW41 (the kind and the qualified name, the signature, the purpose, the
tags, the transitive effects and failures, the module's purpose) and then
its canonical source by the map's location; a module's text is its
purpose, what it needs and imports, and the kind and signature of each
public definition; a module record without a purpose and without
definitions (a file that does not parse) gets no chunk. The id is
sha256: and the SHA-256 of the text. The metadata is an object with the
same keys for every chunk (name, kind, module, package, the map's
id as map_id, text_hash, public, signature, purpose, tags,
see_also, the transitive effects and fails, calls, uses,
tested_by, tested, location), a module's with imports and ids
besides and nulls where it has no value. chunks_lines renders JSON
Lines: a first line with the project, the revision, the toolchain and
the counts of what the lines hold (chunks, modules, definitions), then
one object (id, text, metadata) per line, through
Json::render_line, the one-line renderer added to renyi_syntax::json
beside the indented one. renyi index --chunks [path] writes them (the
command now keeps the canonical files the map is built from, the three
steps of index_files_in spelled out; --chunks does not combine with
--json, --budgets or --diff), and the MCP tool chunks, the
eleventh, answers the same from the resident world, module narrowing
it to one module. Held by tests: on the corpus a chunk per module and
per definition, each id the hash of its text, the text of AW41 for
invoice.total, the module chunk of invoice, a test chunk; the ids
the same after a formatting-only change and after a dependency's body
change (where map_id changes and text_hash does not), different
after the definition's own text, the module's purpose or a callee's name
changed; the lines one object each with the counts of what they hold;
the command and the tool through the binary. Checked against the
prototype of AW41: the 171 definition chunks of the corpus and the 1,576
of compiler/ equal the measured header text byte for byte, ids
included, so what the measure ranked is what the toolchain writes. The
export of compiler/: 1,597 chunks in 2.9 MB, 2.3 s with the debug
binary (Windows wall-clock, coarse; the check is most of it). The
documents: design document 05 gains section 8 (the two after it
renumbered), its tool table a row and its status the stage; positioning
2.3 a sentence and its table the command; the starter's README a row
and a paragraph, its skill the option; the reference's command row; the
README's fourth point and its command list. Next: 37c, the extras of
AW40: the language's documents as chunks (--language) and the example
pipeline in starter/.
AW43. Stage 37c built: the language's documents as chunks and the
example pipeline. 2026-10-13. renyi index --chunks --language writes
the language's own documents in the shape of a project's chunks
(renyi_index::language_chunks): one chunk per section of the cheat
sheet and of the reference (a ## section with text of its own, each
### subsection under its section's heading, the text before the first
heading; the document's title line heads every chunk; a heading inside a
fenced code block is text; kind section, module the document's
name, name the document and the heading, the location the document's
lines), then per module of the library (renyi_check::LIBRARY) the
module's chunk and one per public declaration from its declaration file
(the header of AW41 with the declared effects and failures, then the
declaration's text; a method named Type.method as the map's edges
spell a call to it, so that a host walks from a hit's calls to the
library's chunk; package std and the version; a function overloaded
by its receiver's type argument, List.sum, one chunk per overload
under one name; ability_signature shared with the map's drafts). The
binary embeds docs/reference.md as crates/renyi/reference.md beside
the cheat sheet's copy, both held equal to the documents by
tests/cheat_sheet.rs (decision AI5), so the chunks come from an
installed renyi alone; the header line names the project renyi, the
revision the version, and counts the sections apart (sections, now in
every header line); --language needs --chunks and takes no path. The
MCP tool chunks takes language. The export: 370 chunks (86
sections, 16 modules, 268 declarations: 134 methods, 69 functions, 57
types, 8 abilities), 432 KB; the sections' median 765 characters, the
90th percentile 2,275, the longest 12,637 (appendix A of the
reference); the declarations' median 333. The example pipeline,
starter/retrieval/retrieve.py with its README and section 7 of the
starter's README: the host's side of the loop in eighty lines, the
chunks read, a store of vectors by chunk id, only the ids not seen
embedded with a local model through sentence-transformers and the ids
gone dropped, a question answered with the nearest chunks and the
chunks to read them with (calls, tested_by, see_also). Run on the
corpus and the language with the small model: 571 chunks embedded once
and none the second time; "where do we round money to cents" answered
with Decimal.rounded, Float.rounded and invoice.total with its
subtotal and its two tests; "how does a needs clause grant a
capability with a budget" with the reference's section 11, its grammar
first. CI compiles the script (py_compile) and does not run it: a
model is outside the toolchain. Held by tests: a document cut at its
headings (the title's text, a section with text, two subsections under
their section, a heading in a fence left as text, a heading with
nothing of its own skipped, the lines and the locations); the real
documents and library (the cheat sheet's Control flow, the reference's
8. Control flow / Meaning, at least a chunk per ### of the
reference, std.http with get_with and HttpError,
Decimal.rounded a method, a name and a signature one chunk, the
header line's counts); the command and the tool through the binary;
the copies equal to the documents. The documents: 05 section 8 a
paragraph and its order of work, the reference's command row, the
starter's README and skill, the notes. Stage 37 closes; 35c follows,
then release 0.2 (AW36).
AW44. Stage 35c: completion, signature help and workspace symbols in
the language server; both checkers record every binding's
declaration. 2026-10-13, the third stage of AW34's order, which
closes stage 35. renyi lsp answers textDocument/completion (the
trigger .), textDocument/signatureHelp (the triggers ( and ,)
and workspace/symbol (crates/renyi/src/lsp/complete.rs). The
context of a position is read from the tokens of its line before it,
by the lexer: after import, the modules of the library and of the
project whose names start with the path typed, each item replacing
the path (textEdit); in a needs clause, the capability tree
(effects::TREE); after a dot whose receiver is one identifier naming
an import, that module's public functions that are not methods, its
constants and its types; after any other dot, the members of the
receiver's type, the longest expression the checker typed ending at the
dot (Target::Typed, decision AU1): a record's fields, the methods
declared on the type (World::method_index), the methods of the
abilities it has (Equal for every data type, what it derives, what
is implemented for it), the same of its base for a subtype and the
constraints' abilities' for a type parameter, each name once; at a
bare position, AW34 (3): the bindings declared before the position in
the enclosing item, the module's functions that are not methods, its
constants and its types, the imports' namespaces and the names they
expose, the prelude's functions that are not methods (none today:
every function of the prelude is a method) and, inside a body, the
words that start a statement by the grammar (let, change, if,
match, for each, repeat until, run concurrently, return,
fail, crash with, break, continue, ignore, check); the
items sorted by group through sortText (the locals 0, the module's
1, the imports' 2, the prelude's 3, the keywords 4) and by name, the
editor filtering by the prefix typed; every item described as hover
describes it, the signature as detail and the purpose as
documentation. A prefix that ends inside a text literal is read from
the hole being written (the lexer's Error token starts at the
quote). Signature help: the call found by the innermost parenthesis
still open on the line (a bracket open at depth zero is a list or a
record: no call), the active parameter the commas before the cursor
at that depth; the callee a bare name (the module's function, else
the prelude's), one.name (the import's function or type, else a
method of the binding one), expression.name (a method of the
receiver's type: declared, else an ability's, else the base's for a
subtype) or Name( (a record among the module's types, the exposed
ones and the prelude's, else a variant of a sum type among them); the
signature as hover spells it (function_signature), one label per
parameter the caller writes (self left out), each a part of the
label, the purpose as its documentation; an overloaded method gives
every signature. Workspace symbols: the outline of every file of the
workspace (symbols_of), the parts too, by a case-insensitive part of
the name (every one for the empty query), each with its module as the
container (module.Item for a part). The declarations recorded. A
binding without a use is not in the record of AW39, and a body being
written has such bindings, so both checkers record a binding's
declaration as a reference to itself at bind (Target::Local at
the name's span in check.rs, LocalTarget in bodies.ry), one push
per binding; local_occurrences kept a declaration once already, the
server's local_declared_at is gone, and the rules test lists the
declaration first. The repair. The checker refuses a file the parser
refuses (CheckedModule.id none), and the line being completed is
such a line as a rule (a dot without a member, a call not closed, a
bare name): the workspace would know nothing of the file. For a
completion or a signature request on a file without a module, the
position's line is repaired in the workspace for the request and the
editor's text put back after the answer; the diagnostics are
published before the repair and the repair's never. The line is first
completed: xx (two letters, the lexer refusing one) where an operand
is missing after a dot, a comma, a parenthesis, a colon, an operator
or a reserved word and none follows; the brackets still open closed
at the line's end; ignore before a line that starts with an operand,
which moves the line's offsets by seven; else the line is blanked;
each tried with the parser alone before the workspace is touched, and
the offsets the request names are mapped into the repaired text
(Mapping). A receiver the repair took away, or one that did not
check, is found by its name when it is one: a parameter of the
enclosing function by the function's record, else a binding by the
type the checker recorded at one of its uses. Why: the error-tolerant
analysis editors assume is a parser that keeps a tree and a checker
that checks it; this parser recovers into a tree, but the checker's
contract, no module for a file with a parse error, is what renyi
check and the judges hold, and a repair of one line in the server
keeps that contract at the cost of two refreshes of one file. Measured
on compiler/ through the lane's driver (lsp_drive.py; wall-clock,
coarse; the release binary): initialize 15 ms; a bare completion in bodies.ry 13 ms (431 items, the four bindings first); the members after checker. on a line that parses 5 ms (24 fields); the signature of record( 6 ms; workspace/symbol for check 17 ms (102 symbols); the members after checker. on a line the parser refuses, inserted by a didChange just before, 509 ms (the project checked again after the change and once more after the repair, both in the time), the same 24 fields; the medians of three turns, the lane's timing_35c.log. Held by
crates/renyi/tests/lsp.rs (four buffers and the clean text: the
bare name, the member, the method call being written, the import; the
call inside a hole, the record built, the namespace, the capabilities,
the symbols by a part of the name and all) and by the module's own
tests (the contexts, the calls, the repairs). The documents: the
reference's command row, the extension's README and changelog, the
notes. Stage 35 closes; release 0.2 follows (AW36).
AW45. After release 0.2.0: the measures of the positioning's
section 5, the showcase repositories, the article, the badges.
2026-10-14, the owner's answers after the release and the Marketplace
publish. (i) The announcements (the lane's texts of AW36) are posted by
the owner. (ii) Two showcase repositories under the organisation, each
with a README, tests and CI: renyi-games first, small games over
std.screen that run at the terminal and in the browser, then
renyi-tools, tools that do real work (a static site generator,
Markdown to HTML, a to-do command, bills). (iii) An article on Renyi,
in LaTeX, for arXiv under cs.PL cross-listed to cs.AI: the design, the
implementation and the measures below with the benchmarks of AG4, the
readability rounds and the self-hosting ratio; the owner's arXiv
account has published in astronomy only, so an endorsement for cs.PL
may be asked at submission. (iv) Both badges: the Marketplace's
verified domain (a TXT record on the site's zone through the one-hour
token flow of AI2, the session adds it) and Open VSX's namespace claim
(an issue on the registry's tracker from the owner's account, the text
written in the lane, the owner asked before it is opened). The measures
of 08-positioning.md section 5, taken the same day against release
0.2.0: claim 3, reproduction: the five workflows of the starter pack
were recorded on Windows with renyi record (0.2.0 from cargo
install) and renyi reproduce passed on every recording under Linux
with the binary install.sh put in place ("the outcome and the output
are the recorded ones", five of five). Claim 2, the first-run rate:
five tasks of the workflows' kind (expenses by category from a CSV, a
log's levels and top errors, word frequencies, an inventory's low
stock and value from JSON, a rename plan from a directory listing and
an argument), each given to a fresh agent (a Claude Code subagent)
with the skill file and the cheat sheet alone, no MCP server, no other
file of the repository, and the release binary; the attempts to a
clean renyi check: one, one, one, three, two; renyi test and
renyi run passed on the same attempt in every task, the outputs
checked against an independent computation. Every failed attempt but
one was answered by a diagnostic whose fix the agent applied
(unknown-field on path.name, fix .name(); error-not-declared
naming JsonError); the exception was expected on or fails with
FileError, JsonError, whose fix did not name the spelling with or,
found by a guess. The gaps the agents named (the spelling of two error
types, JsonError, the library types' members as methods, what
filesystem.list and Map.entries answer, which library calls answer
maybe) are one bullet more in starter/skill/renyi/SKILL.md; the
cheat sheet, token-budgeted, is unchanged. Claim 1, the review time,
is a person's measure and is the owner's; pending. The lane:
measure02/ (the recordings rec/, the tasks and the programs
firstrun/tasks/, the results firstrun/results.md).
AW46. The owner's answers after the design study of stage 40, the C
API: JSON across the boundary, a crate of its own with a hand-written
header, C and Python first, a library archive per target. Asked on
2026-10-15 after the study (the handoff's section "Stage 40, the C
API: the design study (session 15)": the Rust API of AP1 and AP2 as
the layer below, the web crate's C ABI by hand as the pattern, the
JSON codec of std.json as the way a value crosses, the cdylib's
own allocator as the count the memory budget means; AskUserQuestion,
one batch of four). (1) Values across the boundary: JSON texts both
ways (recommended), the arguments as one JSON array decoded against
the declared parameter types before anything runs and the answer as
one JSON text in the codec's rules, over a value handle API of thirty
functions with an ownership rule each, and over JSON first with the
handles scheduled as 40c; a function whose parameter or result the
codec cannot carry is listed as not callable and refused with the
reason. (2) The library: a new crate renyi_c, cdylib and
staticlib over renyi::Sandbox, with include/renyi.h written by
hand and held equal to the exports by a test (recommended), over
cbindgen in the build and over the renyi crate itself made a
cdylib; the crate declares renyi::Allocator, so a host gets the
memory budget with no declaration of its own. (3) The first stage's
hosts: C and Python through ctypes, one file of the standard
library (recommended), over C alone and over C, Python and Node
through koffi. (4) The packaging: a fourth release artifact per
target with the shared and static libraries, the header, the Python
binding, the C example and a README, and the crate on crates.io with
the others (recommended), over crates.io alone. The stages the
answers set: 40a the crate, the header, the handles, load,
load_source, functions, module, warnings, grant, call and
call_guarded, the texts and the statuses, the Rust tests over the
exports, the header held equal, the C example compiled and run in
CI; 40b the Python binding and its run in CI, the fourth artifact,
the crate on crates.io at the next release, the documents, the
measure; 40c when a host asks: the screen callback, the value handles
beside the JSON path. (user)
AW47. Stage 40a built: the crate renyi_c, the header, the C
example in CI. Done on 2026-10-15 as AW46 set it. Sandbox::call_json
in the renyi crate (the arguments as one JSON array text, each item
decoded through the codec of std.json against the type the program's
type table holds for the parameter, FunctionMeta::param_type_indices
into Program::result_types; a parameter the table has no type for
makes the function not callable, a new field of Function, and a
call to it is refused with the parameter named; the guards applied
through guarded; the value encoded and rendered as one text), with
the VM made by a free function over the sandbox's fields so that
call and call_json share it. The crate renyi_c: cdylib,
staticlib and rlib, the counting allocator declared, the handle
Handle holding the sandbox, the text of the last call, the exit
code and the memory limit and peak; the exports renyi_api_version,
renyi_version and _len, renyi_load, renyi_load_source,
renyi_free_sandbox, renyi_last_error and _len (per thread),
renyi_text and _len, renyi_call, renyi_call_guarded,
renyi_exit_code, renyi_memory_limit, renyi_memory_used,
renyi_module, renyi_grant, renyi_warnings, renyi_functions;
the statuses 0 to 5 as AW46's study listed them; the header
include/renyi.h by hand, with a test that reads every
renyi_<name>( of the header and holds the set equal to the exports.
Seven tests over the exports: the description and the calls (a record
in and out, a variant, a text, the failure, the crash and the memory
budget at 8 megabytes), the refusals (the wrong shape, the arity, an
unknown function, bad JSON, an argument text that is not an array, an
uncovered need), the guards, two handles with budgets of their own,
the load failures, the version. The C example examples/host.c over
calc.ry, which CI compiles with cc against the debug library and
runs, its output compared with host.expected; standard output
flushed before each call so the module's console lines come in order.
The codec's failure is rendered as the module would see it
(Mismatch(path: ..., expected: ..., found: ...) of std.json), not
reworded. Not in this stage: the Python binding, the release artifact
and the crate on crates.io (40b), the screen callback and the value
handles (40c). (Claude)
AW48. Stage 40b built: the Python binding, the library archive, the
crate for crates.io, the measure. Done on 2026-10-15 as AW46 set it.
bindings/python/renyi.py, one file over ctypes and the standard
library: Sandbox.load(path, grant) and Sandbox.load_source(name,
text, grant) with the grant a dict, a JSON text or None, a context
manager with close; call(name, *arguments, guards=None) with the
arguments as Python values through json.dumps and the value back
through json.loads, the other statuses as the exceptions Failed,
Crashed, Exited (with code), Refused and OverMemory (with
limit and used) under RenyiError; module, grant, warnings,
functions(), version(), api_version(); the library found
through RENYI_C_LIB, else beside the file (the archive's layout),
else under target/release and target/debug of the checkout the
file sits in, else by the system's loader, and refused when its API
version is not the binding's. bindings/python/example.py is the C
example in Python, its output example.expected, which CI runs and
compares in the step of 40a. The release workflow builds renyi_c
for every target and packages renyi_c-<version>-<target> (.tar.gz,
.zip on Windows) with the shared and the static library, the
header, the binding, the example, the C example, the license and
bindings/README.md; the release notes name it; docs/RELEASE.md
lists renyi_c as the ninth crate, published last. A bug the
binding's measure found: Sandbox::load compared the path as given
with the map's file names, which the index spells with slashes, so a
Windows path with backslashes was refused with "has no module in the
map"; fixed in Sandbox::of by the same spelling, with a test on a
backslash name through load_source. The measure (wall time on the
owner's Windows machine, two runs each, the release library, risky(5)
ten thousand times): the load 2.9 and 2.8 ms from Rust, 10.1 and 9.9
ms from Python (the binding's first import and the file read inside);
a call 37.9 and 42.4 us through Sandbox::call, 36.4 and 43.6 us
through renyi_call (the JSON decode and encode within the noise of
the VM made per call), 57.7 and 51.1 us from Python, and 62.7 and
57.3 us for shift with a record in and out; all under the hundred
microseconds the study expected, the VM's construction per call the
larger part, as it said. Not in this stage: the screen callback and
the value handles (40c, when a host asks). (Claude)
AW49. The owner's answers on stage 41, the Python bridge's items
(2026-10-15, after the study in the handoff): a deadline per Python
call comes from the manifest, a deadline of the python section
that a module's entry may override, a Duration text such as "5
seconds", none meaning unbounded as before; a call past it fails with
a new variant TimedOut(after: Duration) of PythonError, the worker
killed and started again at the next call; the binder generates a
record type for a dataclass, a NamedTuple and a TypedDict, the
three kinds whose fields Python states, and the worker converts at
the boundary by the function's annotations; the item "one worker
across a test run" is closed as done, the tests of a file sharing the
Vm and its worker already, each file of a run keeping its own. The
study's experiment: two tests of one file calling Python start one
worker; the interpreter's start is about 245 ms per file. The
alternatives the owner did not take: the enclosing concurrently
within deadline as the source (it bounds only the calls inside such a
block), both sources with the nearer taken (later, if a program asks),
Unavailable with the time in its text (a program could not tell a
slow call from a missing interpreter), dataclasses alone, plain
annotated classes built through __init__ (which holds for some
classes and not others), and a worker shared across the files of one
manifest (a quarter second per file, for moving the worker out of the
Vm). The stages: 41a the deadline, 41b the record types, 41c the
roadmap's item closed. (user)
AW50. Stage 41a built: the deadline per Python call (2026-10-15).
The manifest's python section takes deadline, a text of a count and
a unit (millisecond, second, minute, singular or plural; the count
whole, above zero, at most a thousand million), and so does each
module's entry, the entry's winning for its module; the manifest
renders it back as the largest unit that divides the milliseconds.
PythonModule carries the entry's and PythonBinding the resolved
deadline in milliseconds; the VM's binding, the bytecode file (format
11: "deadline" after root, a number or null) and the binary
encoding (9) carry it, and compiler/project.ry, declare.ry,
bytecode.ry and emit.ry read and write the same. The worker's
output is read by a thread of its own into a channel, so Worker::call
waits with recv_timeout where a deadline is set and recv where
none is; past it the call answers NoAnswer::TimedOut, the VM drops
the worker (killed and waited for; the thread ends at the pipe's end)
and the call fails with TimedOut(after: Duration), the fifth variant
of PythonError, the next call starting a worker again. The fixture's
analysis.stall(3) under a deadline of one second prints timed out
after 1s and the call after it AGAIN!; the binary test takes an
entry's 250 milliseconds under a section's minute, a sleep of five
seconds, a run under four seconds, the file carrying 250, and a
"deadline": "soon" refused with the resolver's text. The gates:
fmt, clippy with -D warnings, 67 suites green (the selfhost
judges among them, the Renyi resolver reading the fixture's deadline),
the lint, the token budget, the web crate for wasm32 (the thread
compiles there and is never started, the page serving no Python). No
Python process is left behind (the count before and after a run is
the same). The documents: docs/python.md sections 1 and 5, the
reference's bridge paragraph, the sketch's section 15, the roadmap's
stage 41 and track E. (Claude)
AW51. Stage 41b built: record types from Python classes
(2026-10-15). The inspection script reports, beside the functions,
the classes the annotations name whose fields Python states: a
dataclass, a NamedTuple or a TypedDict, each with its kind, its
bare name, whether it is generic, its own docstring's first line and
its fields (name, annotation tree, required, taken by the
constructor), the fields' classes reported in turn. The binder settles
them into record types, each after the classes its fields name: a
public type with a has line per field by the mapping of AM2 (a key
a TypedDict does not require as maybe), can ToJson and can
FromJson, the purpose from the docstring or "The Python class
<qualified>."; a function's parameter or result of such a class is
declared as the type. A class stays JsonValue with the reason in the
comment when it is generic, has no fields, has a field its constructor
does not take, has a field whose name is not a Renyi value name as it
is (the JSON key must stay the Python name), has a bare name that is
not a type name or is taken by the prelude, the JSON and time modules,
PythonError or an earlier class, or names itself through its
fields. The worker converts at the boundary by the function's own
annotations, read once: a JSON object into a dataclass or a
NamedTuple through cls(**fields) and the fields' own annotations,
through Optional, Annotated, lists and maps; a TypedDict stays a
dict, an unrequired key that came as null left out; a dataclass or a
NamedTuple in the result rendered as the object of its fields (a
NamedTuple would otherwise cross as a list). The VM and the checker
are untouched: the record decodes and encodes by its declared type as
any record does. The tests: the fixture's shift through a dataclass
(11 12 in the expected output), the binary test's package with the
three kinds and a nested dataclass, bound and called through the
generated module, the unit test with eight classes of which four are
refused. The documents: docs/python.md section 3, the reference's
command row, the handoff's binder section, CLAUDE.md. (Claude)
AW52. The owner's answers after the study of stage 42: the emitter's
own round, Renyi first, the grouping by a query, the keys as records,
the VM items measured each (2026-10-15). The study (the handoff's
section "Stage 42, the emitter's own round for the compile row: the
design study (session 15)") measured the compile row at 2,590.8 million
instructions on d18ec06 (7.09 against the reference binary of AU34,
13.25 at AU58's study), the emitter 1,098.4 of it, the front end
1,198.4, the rendering as JSON 204.6, and found the emitter's shape:
the type table searched linearly, function_at linear, the references
grouped by appending to a list the map still holds (quadratic, 315.0
million), the map keys built as texts per lookup (204.4), the liveness
walk, the JSON writer's allocations, the frees at the end. Four
questions were put; the owner took the recommended answer to each. (1)
The round runs, the compile row's instruction count its measure, the
Renyi-only stages first: 42a the type table and the functions by map,
42b the references grouped in one pass, 42c the keys as records; the
VM's items after them. AW27's finding stands (the ratio has no
consumer); what the round buys is the shape of compiler/emit.ry, the
program the language's users read as its reference program, written
as the language intends. (2) The references are grouped by a group
by query, which the VM groups in one pass; a hand-written pass only
where the query falls short. (3) The keys are the records themselves:
Span with can Hash derived, a record of the owner and the body;
not Integers packed by hand, not the texts. (4) 42d, the JSON writer
in the VM, and 42e, the frees at the end of a renyi command's run,
are both in, each measured first on the compile row and bench/ and
kept only where it pays; a budgeted or embedded run keeps its frees.
(The owner, through the four questions)
AW53. Stage 42a built: the emitter's type table and its functions by
map (2026-10-15). compiler/emit.ry keeps type_indices, a Map of
Ty to Integer, beside the program's result_types, as the Rust
emitter keeps its index beside the table: type_index looks the type
up and appends it with its index only when new, known_type_index is
the lookup; Ty derives Hash (compiler/types.ry). function_at
takes the context and looks the body up in functions_at, a Map of
BodyKey to Integer built once by functions_by_body in
new_context; BodyKey is the record of the owner and the body
location, with Hash derived. The measure (the perf lane,
measure_stage.sh 42a, callgrind on the Linux release build, the
image): the compile row 2,590.8 to 2,407.2 million instructions,
-7.1%, the ratio against the reference 7.09 to 6.58 (the estimate was
-150 million); the check and parse rows unchanged (1,291.5 and 631.8);
hashing and equality 140.5 to 102.6, comparisons 63.7 to 6.9, the
generated code 977.2 to 882.5. The bytecode the Renyi compiler writes
of compiler/bodies.ry is byte for byte the Rust compiler's (the
derives of Ty and the type ids after it shift in both). A derived
Hash is not checked against the fields' types by either checker
today (the reference says it derives from the structure); the VM
hashes every value by its structure, so a record key hashes as the
reference says. (Claude)
AW54. Stage 42b built: the references grouped by a query
(2026-10-15). new_context groups each module's references by body
with for each reference in entry.references group by refs_key(...)
and stores each group under its key once; targets_of is the query
for each reference in references group by span_key(reference.span)
collect reference.target. The VM groups in one pass (GroupInsert),
so no list is copied while it grows, where the loops of get,
append and set copied the list the map still held at every append.
The measure (measure_stage.sh 42b): the compile row 2,407.2 to
2,300.8 million instructions, -4.4%, the ratio against the reference
6.58 to 6.29; new_context 205.0 to 114.0 million inclusive,
targets_of 111.0 to 95.2 (its lists are short, one or two targets a
span; what remains there is the key built as a text, stage 42c's
item), counts and drops 250.5 to 196.5. The estimate of -250 million
was too high: the quadratic copies were about 107 million, not 250;
the study's attribution of the clones and the memory copies to them
was partly wrong, the rest being the texts of the keys. The bytecode
of compiler/bodies.ry byte for byte the Rust compiler's and 42a's.
(Claude)
AW55. Stage 42c built: the emitter's map keys as records
(2026-10-15). The references of a module's bodies are kept under
BodyKey, the record of the owner and the body location, and a body's
targets under its Span: Span (compiler/ast.ry) and BodyLocation
(compiler/declare.ry) derive Hash, targets_of groups by
reference.span and targets_at looks the span up as it is;
body_key, maybe_key, span_key and refs_key, which formatted a
text per lookup, are gone. The measure (measure_stage.sh 42c): the
compile row 2,300.8 to 2,127.8 million instructions, -7.5%, the ratio
against the reference 6.29 to 5.82; compile_project 808.3 to 635.3
million inclusive, new_context 114.0 to 50.4, targets_of 95.2 to
41.3, targets_at 81.9 to 26.2, the natives 480.4 to 399.8, VM other
169.5 to 120.4. The three Renyi stages together: 2,590.8 to 2,127.8,
-17.9%, the ratio 7.09 to 5.82, the emitter's own part 1,098.4 to
635.3. The bytecode of compiler/bodies.ry byte for byte the Rust
compiler's (the two derives shift the ids in both). What the profile
shows next in the emitter: emit 213.9 million inclusive for 29,840
calls with type_index_at only 54.9 of it, which points at its three
appends copying their lists (the Step record that carries the
emitter is still held by typed when updated.ops is read, so the
record is held twice and the field is cloned, not taken); and the
liveness walk, walk_block, 181.7 million (8.5%). (Claude)
AW56. Stage 42f built: emit reads the index before the emitter
(2026-10-15). emit read typed.emitter into updated and
typed.value afterwards, inside the with; the Step record was
alive through the three appends, so the emitter record was held twice,
updated.ops was cloned rather than taken (the Takes plan of AU11
moves a field out of a record held once), and every append copied its
list: the quadratic copy of AW55's finding. The index is now read
first, so the read of typed.emitter is the last read of typed and
moves the record out, and the appends work in place. The measure
(measure_stage.sh 42f): the compile row 2,127.8 to 2,056.7 million
instructions, -3.3%, the ratio against the reference 5.82 to 5.63;
emit 213.9 to 142.5 million inclusive, counts and drops 193.2 to
168.7, VM other 120.4 to 95.7; compile_project 635.3 to 564.0. The
bytecode of compiler/bodies.ry byte for byte the Rust compiler's. A
lesson for the reader of compiler/: a Step is taken apart value
first, emitter last. (Claude)
AW57. Stage 42d built: the JSON writer without the allocation per
line, the formatter for an Integer and the scan of a plain text
(2026-10-15). The VM's render and render_indented already wrote
the text as the value was walked (TextSink, the round of AQ); the
study's finding 7 was wrong to say a tree was built. What cost was
three things in the writer: renyi_json::newline allocated
" ".repeat(indent) for every line (356,542 lines of the compile
row's file), every Integer went through core::fmt as a dyn Display,
and write_string walked every byte of every text although almost
none needs an escape. Now newline copies from a constant run of
spaces, Sink has integer(i64), which TextSink writes through
integer::push_digits for a machine-word Integer and a Duration
(TreeSink as before), and write_string copies a text whole when no
byte of it needs an escape. The measure (measure_stage.sh 42d,
bench42d.sh): the compile row 2,056.7 to 1,958.0 million
instructions, -4.8%, the ratio against the reference 5.63 to 5.36; the
load and the writer's category 80.1 to 37.5, texts and memory copies
131.9 to 73.2, write_string 34.4 to 25.1 million self; of bench/,
json_round_trip 841.5 to 783.6 million (-6.9%) and the others
unchanged; the Rust compile row unchanged at 470.1, because it
renders the bytecode file through renyi_syntax's own JSON type
(file.rs), not this writer. Every program that renders JSON, the C
API's texts and the bridge's lines among them, takes the same path.
The bytecode of compiler/bodies.ry byte for byte the Rust
compiler's and 42f's. (Claude)
AW58. Stage 42e measured and left off: the frees at the end of a run
cost nothing to speak of (2026-10-15). The experiment (the perf
lane's exp42e.sh): the runner patched to flush the console, drop the
Python worker and the JIT, and forget the VM and the program when
RENYI_LEAVE_VALUES is set, so that the values still held at the end
of main are left to the process's exit. The compile row by perf
stat, three runs each: 1,937.9, 1,937.8 and 1,938.3 million
instructions with the frees, 1,938.4, 1,938.1 and 1,938.4 without;
bench/records 278.8 both ways, json_round_trip 808.9 both ways;
the outputs equal. Nothing is held at the end: a program's values die
where their last reads are (decisions AU17 and AU55), so the compile
row's program tree is freed inside render_indented, which consumes
it, and the checker's world when compile_file leaves them; what the
study attributed to the exit (release_last, 97.5 million) is the
frees of the run itself. The patch is not kept; the stage closes with
its measure. (Claude)
AW59. Stage 42g built, Set.union in place, and the round closed
(2026-10-15). The liveness walk of AU55's rule (walk_block, 181.7
million instructions after 42f, 8.8% of the compile row) joins the
names a statement mentions into the set of the names after it twice
per statement, after.union(bound).union(nested.names), and
set_union built a new set from both every time, the cost of the
large set for every statement. The native now takes its receiver and
extends it where it lies when nothing else holds it (Rc::make_mut
and extend, as add does): the cost of the small set, the order of
the entries the same, a copy only when the receiver is shared. Every
program that unions sets takes the same path. The measure
(measure_stage.sh 42g, bench42d.sh renyi_42d renyi_42g): the
compile row 1,958.0 to 1,943.0 million, -0.8%, the ratio against the
reference 5.36 to 5.31; walk_block 181.7 to 159.1; the bench
programs unchanged (none unions sets). What remains in the walk is
two passes over every expression of every statement (expr_mentions
31.5 million and expr_bound 40.5, the names mentioned and the names
bound) and the sets of texts they build; merging the passes would
save about 30 million for a rewrite of two functions of two hundred
ops each, which the round leaves. Noticed with this measure: 42d's
writer also cut the parse row, whose program prints the tree as JSON,
from 631.9 to 540.8 million (-14.4%), which AW57 did not record.
The round's close. The compile row from 2,590.8 (d18ec06) to 1,943.0
million instructions, -25.0%, the ratio against the reference binary
7.09 to 5.31 (13.25 at AU58's study); compile_project, the emitter's
own part, 1,098.4 to 548.8, -50.0%; the front end's 1,198.4 as it was;
the parse row 631.7 to 540.8 through 42d; the check row unchanged
(1,291.5). Six stages in Renyi and the VM: 42a the tables by map
(AW53), 42b the references grouped by a query (AW54), 42c the keys as
records (AW55), 42f emit's Step taken apart value first (AW56),
42d the JSON writer (AW57), 42g the union in place (this entry); 42e
measured and left off (AW58). The bytecode the Renyi compiler writes
stayed byte for byte the Rust compiler's at every stage, the four
derives (Ty, Span, BodyLocation, BodyKey) shifting the ids in
both. The emitter's remaining shape, for whoever reopens the row: the
liveness walk 159.1 million, emit 142.5 (its three appends through
the Takes plan, about 70 of it), type_index_at 54.9, the rest
spread over the rules under 10 million each. (Claude)
AW60. The owner's answers on gap 1.11, the effects of a function value
(2026-10-15). The study (docs/HANDOFF.md, stage 43) measured the
rule with eight probes: B1 charged only a function name written directly
as an argument of a declared function's call, so a let binding, a list
literal, a return and a record field each lost the charge, the program
checked clean and crashed at its first primitive; the needs written on a
function type were documentation (a function(Text) parameter took a
function needing console); and the reference's "the higher-order
function's own needs narrows it" was true of scopes only, since
grant::within passes the kinds the needs do not mention through. The
owner's answers, recommended first:
- The rule: charge at the name. A function named as a value is
charged, with its needs, to the body that names it, wherever the
value goes: passed, bound, stored in a collection or a field, or
returned. B1's "charged where it is passed" reads "charged where it
is named"; a higher-order function still declares only its own
effects; V9 and the run-time rule stand. The checker charges at the
two sites where a name becomes a value (a bare name,
module.function) and no longer at the call that receives it (check.rs,charge_named;bodies.rythe same, decision AD1). The alternatives were the needs in the type checked both ways (a reversal of B1 and V9, the corpus's higher-order functions declaring what they call) and documenting the hole. - A function type that lists
needsbounds the value's. The value may need at most what the type lists (type-mismatch, the types shown with their needs); a type withoutneedstakes any value, as before, soretry.ry,serve's handler and the compiler'sparse_listare unchanged. - The diagnostic is
capability-missing, the same message and fix as a direct argument's, at the name's span; no new code. - The run-time sentence is corrected, not the VM: "narrows its
scopes". The VM is right, since the name's charge is what puts the
passed function's kinds in
main's grant.
The conformance cases function_value_bound.ry, function_value_stored.ry,
function_value_returned.ry, function_value_field.ry and
function_type_needs.ry; rules.rs gains the two shapes; the reference's
section 3 and section 7; docs/GAPS.md 1.11 closed. (user)
AW61. Stage 43 built: a function value charged where it is named, a
function type's needs a bound (2026-10-15). The Rust checker charges
a function's needs at the two sites where its name becomes a value
(check.rs, charge_named, called from the bare name and from
module.function), the call of a declared function charges only the
callee's own needs and check_args no longer collects the functions
passed (Info.function is gone), and the assignability of a function
type adds needs_ok: when the expected type lists needs, every need of
the value is covered by one of them (effects::covered, strict). The
Renyi checker makes the same four changes (compiler/bodies.ry,
charge_named, charge_effects without passed, check_args
returning the checker, assign_functions with needs_ok; the Info
record loses function_id), and the selfhost judge holds it byte for
byte to the Rust checker on the corpus, the conformance suite and the
compiler. The conformance suite gains function_value_bound.ry,
function_value_stored.ry, function_value_returned.ry and
function_value_field.ry (capability-missing) and
function_type_needs.ry (type-mismatch, "the argument is
function(Text) needs console, but function(Text) needs time is
needed"); rules.rs gains the four shapes and the bound; the reference's
section 3 (the rule, the static rule, the run-time sentence "narrows its
scopes") and section 7; docs/GAPS.md 1.11 closed. The corpus, the
starter pack, the showcase and the compiler check as before: none of
them names a function anywhere but as a direct argument, and none of
their function types lists needs. One residue, recorded as docs/GAPS.md
1.19 and sketch item R3-3: a function whose return type is a function
type cannot declare its own needs or failures, since the grammar has no
parenthesised type and the clause after returns function(...) belongs
to the type; under this rule such a function that returns an effectful
name is refused and has no way to declare what it needs. Gates: fmt (clean after rustfmt), clippy, cargo test 67 suites OK, the format check of compiler/ and bench/, the corpus lint, the token budget and the wasm build green (the perf lane's gates43.log).
(Claude)
AW62. The owner's answers on gap 1.19, the clauses after a returned
function type, and the correction of AW61 (2026-10-15 evening). The
study (docs/HANDOFF.md, stage 44) found the grammar unambiguous but
unable to say one thing readably: after returns function(...) the
three clauses are the function type's (parser.rs, type_; the Renyi
parser the same), and the sketch, the corpus and the library never
return a function type. AW61's residue said a function returning a
function type "has no spelling for its own needs"; that was wrong,
found while building: the clause word written twice is parsed as the
type's then the declaration's (function pick() returns function(Text)
needs console needs console checks, runs and is canonical, the probe
twice_needs), so the gap is readability, not expressiveness, and the
owner kept the decision after the correction ("照做括号"). The owner's
answers, recommended first unless said:
- A parenthesised type.
Type ::= 'maybe' Type | FunctionType | TypeName ('of' TypeArguments)? | '(' Type ')': the parentheses group and are no type of their own, the tree has no node for them (decision W1 untouched, both parsers give the inner type with its own span), and a returned function type followed by the declaration's clauses is writtenreturns (function(Text) needs console) needs console. The alternatives were the clauses after a returned function type rebound to the declaration (a meaning change for text that parses today, and the parentheses needed anyway for the other reading) and leaving it. - The canonical layout parenthesises every returned function type
(the owner's choice over "only where the declaration's clauses
follow"):
returns (function(Text)),returns maybe (function(Text) needs console), in a declaration's signature and in a function type's ownreturns; the formatter writes them and drops parentheses around any other type, so the clause word twice formats to the parenthesised form. - Parentheses group any type:
(Integer)andList of (Text)are accepted and formatted away; one rule, no exception, no new diagnostic (a parenthesis left open is the existingexpected, "write)"). - The cheat sheet is unchanged: it shows no function type and stands at its budget; the reference and the grammar file carry the rule.
A surface change under V11: this entry, then the grammar file, the reference (sections 3, 4 and 16), the formatter, the conformance suite and both parsers in one commit. (user)
AW63. Stage 44 built: the parenthesised type (2026-10-15 evening).
docs/grammar.ebnf and the reference's excerpt gain the alternative;
parser.rs reads ( Type ) inside type_ with the nesting raised
between the parentheses as a function type's parameter list does, and
compiler/parser.ry the same in parenthesised_type (decision AD1:
the same cursor moves, past_symbol for both parentheses, the inner
type the node); renyi parse --json prints the same tree from both on
the probes. The formatter's returned_type_text writes a returned
function type in parentheses, directly or under maybe, in a
declaration's signature and inside a function type, and drops them
elsewhere; a format test holds the clause word twice to the
parenthesised form and List of (Integer) to List of Integer. The
conformance suite gains function_type_parens.ry (a returned function
value under the returner's own needs, run); grammar.rs gains an
accepted corner and a rejected one; rules.rs gains the clean twin
of the returned shape; function_value_returned.ry is in its new
canonical form. GAPS 1.19 and sketch R3-3 closed; the cheat sheet
unchanged at 3,000 of 3,000 tokens. Gates: fmt, clippy, cargo test 67
suites ok, format check of compiler/ and bench/, lint, tokens, wasm, all
exit 0 (gates44.log, 19:29:47). (Claude)
AW64. Stage 45, the memory budget written in the program (GAPS 3.6):
the owner's answers (2026-10-15 evening). The study is the handoff's
section "Stage 45". Four questions, the recommended option chosen each
time:
1. memory in the grant, with a budget in bytes: needs console,
memory at most 256 megabytes. memory is a path of the capability
tree that no primitive needs, so it stands only in the needs of
main or of a test, and only with its budget; Budget ::= 'at most'
Integer ('per' TimeUnit | 'bytes' | 'kilobytes' | 'megabytes' |
'gigabytes'), no reserved word added. The reviewer reads the whole
grant in one clause (P2's reason). This supersedes AP1 (iii) in part:
the mechanism of AP1 (the counting allocator, the flag read at the
safe points, the crash with the limit and the peak) stands; "the
budget is the host's to set, not the program's to declare" does not,
and open item R7-1 is closed again by this entry. The sandbox file's
memory and the embedding API's stay as the host's tightening: the
smaller of the host's and the program's is in force. The
alternatives: a clause of its own on main (within 256 megabytes:
a second home for what the reviewer reads as the grant, and within
the deadline word), and keeping AP1 (the probes of the study: a
runaway recursion takes 700 megabytes a second with nothing to stop
it where no host set a budget). 2. Over the budget, a crash, as
now: exit status 2, "the memory budget of 16 megabytes was exceeded
(24 megabytes held)". A failure the program could handle was the
alternative; the handler would run with the budget spent. 3. No
depth or step limit: the memory budget is the guard. The probes
showed a frame of a plain recursion costs about 140 bytes and the
native stack is not at risk on any tier (ten million frames in 2.3
seconds, no overflow), so a depth number of the VM's own would be a
hidden constant on the hottest path, and a step budget a cost on
every tier that no reviewer can relate to the program's work. 4.
The cheat sheet names the clause on its "Only there:" line, and a
line elsewhere is trimmed to pay for it.
A surface change under V11: this entry, then the grammar file, the
reference, the cheat sheet, the formatter, the conformance suite and
both parsers in one commit. A budgeted run stays on the interpreter
(AP1, AG3); whether the generated code can keep the budget at its
allocating helpers within AU1's one percent is the stage's second part,
to be measured. (user)
AW65. Stage 45a built: the memory budget in the grant (2026-10-15
evening). docs/grammar.ebnf and the reference's excerpt gain the
memory units in Budget; budget in parser.rs and parse_budget in
compiler/parser.ry read per and a unit of time or a unit of memory,
the one diagnostic for neither ("expected per and a unit of time, or a
memory in bytes, kilobytes, megabytes or gigabytes, found
weeks", decision AD1); the tree is Budget's as before, the unit's
text saying which kind (decision W1, no change). memory joins the
capability tree in effects.rs and effects.ry, covered by every grant
since it is a budget and not an effect; both checkers refuse it on a
function other than main, without its budget or with a unit of time,
and refuse a unit of memory on network, process or filesystem, all
grant-clause. The formatter spells a memory budget without per. In
the VM, grant::memory_of reads the declared budget in bytes,
begin_run puts the smaller of it and the host's in force
(Vm::budgeted), a test's own the same way, and a program whose main
or test declares one runs on the interpreter as a host's budget does;
the recording's grant spells it memory at most 256 megabytes and reads
it back. The reference's section 11 (the grammar, the tree, the grant
clauses, the static rules, the command line) and appendix B; the cheat
sheet at 2,996 of 3,000 tokens, the purpose: sentence shortened to pay
for the clause; the conformance suite gains five cases (over the budget,
exit 2; within it; misplaced; bare; the units crossed); rules.rs,
grammar.rs, the parser's, the formatter's, the effects' and the
grant's unit tests; sandbox.rs drives the binary through the program's
budget alone, the file's tightening the program's and the program's
tightening the file's. The embedding guide, the system design's section
4.2, the sketch's section 11 and GAPS 3.6 say the same. Gates: fmt,
clippy, cargo test 67 suites ok, format check of compiler/ and bench/,
lint, tokens, wasm, all exit 0 (gates45.log, 20:30:43); the parse and
check judges equal on the probes. 45b, the budget kept by the generated
code, is open. (Claude)
AW66. Stage 45b built: the memory budget kept by the generated code,
under a budget only (2026-10-15 evening). A budgeted run no longer
stays on the interpreter: the sentence of AP2 ("a budgeted run stays on
the interpreter, as a narrated or profiled one does") is superseded,
AG3's rule for narrated and profiled runs stands. The mechanism: the
allocator's flag is a byte of the memory module (memory::OVER), whose
address the VM's NativeState holds (over_memory, from
memory::over_flag); the generated code of both tiers reads the pointer
and then the byte at a body's entry (the prologue, after the node is
linked) and before every backward jump (Jump, JumpIfFalse,
JumpIfTrue, JumpIfAbsent, JumpIfFailure with a target at or before
the op), and when it is set calls rt_over_memory, which parks the
interrupt as the typed entries' typed_over_memory does, and the body
leaves. Why these two points: a run that allocates without bound runs
ops without bound, so it passes a back edge or a body's entry without
bound; a straight line of ops allocates a bounded amount; so the
overshoot past the budget is one body's straight line, as on the
interpreter, whose checks are at the calls, the returns and the backward
jumps. The alternative, a check inside every allocating helper, left the
plain constructors (rt_construct_plain, rt_make_list,
rt_record_copy), which answer no status, uncovered: a recursion
building a tree of plain records escaped it. The first build kept the
byte inside the VM's own state, registered with the allocator at
begin_run; the sandbox's vm_for returns its VM by value after
begin_run, so the registered address dangled and the test
a_memory_budget_stops_a_call_that_grows_past_it found the budget
ignored: a static's address, read through the state, holds wherever a VM
moves, at one more load per test. The JIT's compilations are left out of
the count (memory::exempt, a thread-local the allocator reads only
while a budget is in force): the compile thread's work and the templates
made on the run's own thread, so that the machine code made for a run is
not the run's memory; a template or a code object freed after its exempt
making lowers the count by a few kilobytes, which only loosens the
budget.
The first measure, with the guard in every program's code, by perf
stat user-space instructions on the Linux release build (the lane's
measure_45b.sh; renyi_45base is 0cfaf08): the check row from the
image 1,278.2 to 1,294.6 million instructions (+1.3%); primes 266.7 to
298.5 million (+11.9%), strings 445.8 to 453.7 million (+1.8%), records
154.2 to 157.2 million (+1.9%), json_round_trip 783.6 to 784.0 million
(+0.04%), hello unchanged. The check row and three of the four
benchmarks over AU1's one percent, primes far over it: a loop of a few
ops pays the two loads and the branch at every turn. The owner's choice,
asked with the measure (keep it, generate the guard only under a budget,
or leave a budgeted run interpreted): the guard only under a budget. So
Jit::guard_memory says whether the generated code tests the budget:
set by Vm::new when the host gives a budget (Options::memory, from
--sandbox or the embedding API) or the program declares one
(grant::declares_memory: main or any test), and by image::build
when the program declares one, every run of such a program being under a
budget; codegen::compile and template::compile take it and
memory_guard emits nothing without it. The image's header records it
(Header::guarded, image format 11), and Jit::load_image leaves an
image's code whose flag disagrees with the run's need, the run compiling
its own with the message "the image's code carries no memory guard and
this run is under a memory budget; the run compiles its own code"; the
image cache (decision AU10) is not consulted and not written by a run
under a host's budget of a program that declares none (consult_cache),
since the cached image of such a program carries no guard. The second
measure, the same way (measure_45c.sh, renyi_45c the stage): the
check row 1,277.4 million instructions against the base's 1,278.2
(-0.06%); primes 266.7 million (-0.01%), strings 445.9 million (+0.02%),
records 154.2 million (-0.01%), json_round_trip 783.0 million (-0.08%),
hello 5.24 million (-0.06%): within the noise, nothing paid; a program
under a budget pays the first measure's cost and runs on the JIT, where
before it ran interpreted. The test
a_memory_budget_holds_on_every_tier drives the binary through a loop
that pushes, a recursion that only calls and a recursion that only
builds plain records, each compiled at its first call on the Cranelift
tier and on the template tier, each stopped with the budget's message; an_image_carries_the_memory_guard_only_for_a_program_that_declares_a_bud
get builds the image of a program with the clause (guarded, stopped by
its own code) and of one without (unguarded; under --sandbox with a
memory budget its code is left and the run's own stops), and the
conformance suite runs the memory cases on the JIT as every run case.
The reference's section 11 and appendix B and the embedding guide's
section 4 no longer say a budgeted run is interpreted. Gates: fmt,
clippy, cargo test 67 suites ok, format check of compiler/ and bench/,
lint, tokens, all exit 0 (gates45c.log, 21:27:39); the wasm build failed
there on the arity of the stub Jit::new, fixed and built clean, fmt and
clippy clean after. (Claude)
AW67. Stage 46 built: the liveness walk's residue on both sides
(2026-10-15 night). The owner's order after 45b ("加速收尾项目,稳定版本", then
the four answers: the stable version is 0.4.0, the unscheduled speed
items go in before its tag, the article's numbers follow it with the
arXiv endorsement request written, and the roadmap's obvious work is
done first), so the two items the roadmap had not scheduled are one
stage. (a) The Rust front end's name sets as bits, the fix AU55 left:
compile/liveness.rs interns each name to a small index the first time
the walk meets it (Walk::intern, one hash per occurrence) and keeps
every set of names as a row of bits (Bits, a Vec<u64> that grows
with the interned names: membership one bit test, the join of the names
after a statement a word-wise or, a frame's later a copy of a few
words), and the mentions and the bound names of an expression are
gathered in one pass (Walk::expr, the mentions wanted or not) where
expr_mentions and expr_bound walked it twice. The measure, the Rust
front end's rows on compiler/bodies.ry under callgrind (the lane's
study_rust_rows.sh, renyi_45c at 94a1a62 against renyi_46a): the
compile row 467.9 to 461.0 million instructions, -1.5%; the check row
177.8 to 177.7 million and the parse row 248.4 unchanged, which run no
analysis; the analysis's own cost under 3 million after it, the
interning's hashing 0.8 million of them. (b) The emitter's single pass,
the residue AW59 left and estimated at 30 million: own_mentions,
own_bound and the two expression families of compiler/emit.ry are
own_level and the _noted family over Noted, a record of the
mentions and the bound names, which a direct caller receives as a pair
(AW9); a name appends its mention through noted with mentions:
noted.mentions.append(...), the update in the slot (AU11), a binding
adds its name the same way (bind), and a pattern's or a loop's
bindings go through bind_pattern and bind_all, which take the set
out of the record so that it grows in place; expr_bound and its family
stay for the names a loop's body binds at any depth, read by
block_bound. The measure (measure_46b.sh: renyi_46a on the base
worktree's compiler/ and on the stage's, by perf stat): the compile
row 1,926.4 to 1,916.6 million instructions, -0.5%, a third of the
estimate, the pair built and taken apart per expression costing part of
what the second walk cost; the bytecode written byte for byte the same
(cmp), the judge of Z3 passing on both sides (four tests, 48.9 s).
Gates: fmt, clippy, cargo test 67 suites ok, format check of compiler/
and bench/, lint, tokens, wasm build and wasm clippy, all exit 0
(gates46.log, 22:22:19). (Claude)
AX. The research track (session 15)#
AX1. The research track opened: a research result as a selling
point, the security measure with two theorems as its line, the free
parts first (2026-10-16 evening). The owner, after the article gained
its second author and its passages of principle and its related work
the three 2025 languages for agents (Quasar, Pel, composable effect
handling): "现在来看arxiv背书的问题 … 我们现在这个文章的深度,放arxiv上合适吗",
then "那我们现在要突破'研究'这个坎。不是工程,不是应用,而是正儿八经的研究突破,
结合到我们的语言中,作为卖点之一". Four lines were put to the owner (the
security measure on AgentDojo with a core calculus and two theorems; a
mechanized formalization alone; a controlled readability experiment
across models; a static analysis of budgets), with the first
recommended; the owner's answers: the first line, "以突破性和创新性为最优先",
and the parts that cost nothing first (the static measure, the calculus
and its statements, the tool bindings), a run with a model in the loop
only after the owner approves the spend. The lane is
D:/Projects/.worktrees/Renyi/research/ (the AgentDojo checkout, the
scripts before they moved into tools/authority_gap/, the data). (user)
AX2. The authority gap measured on AgentDojo: 90.5% of the
benchmark's attacks need an authority the benign task's program would
never declare (2026-10-16 evening). The question: for a pair of a
user task and an injection task, does the injection's ground truth fit
inside the smallest grant the user task's program can declare in the
needs of main? AgentDojo's v1 suites at commit 089ed468 (86
user tasks, 27 injection tasks, every user task of a suite paired with
every injection task of it, 567 pairs; the benchmark's own paper counts
97 and 629 over a later version), the task files read as syntax trees
and never run (tools/authority_gap/extract_tasks.py), a tool a
capability kind with the argument naming a recipient, a URL, a channel,
a hotel, a file or a participant list as its scope, and four grants: the
kinds alone; a scope declared when every call's scope is a literal the
user's prompt spells out (what the program can write); the same with
at most n per run, n the ground truth's count; and every literal as
a scope, an upper bound. Blocked: 475 of 567 (83.8%) by kinds, 513
(90.5%) with the prompt's scopes, 515 (90.8%) with the counts, 539
(95.1%) at the ceiling; 20 pairs (3.5%) are one speech-only injection
against travel's tasks, which no grant touches; the 32 that fit the
third grant are 11 where the task's own sink is the attack's (banking
UserTask15 names the attacker's account as the new landlord, 7;
UserTask14 changes the password, 1; three slack tasks message Alice,
3) and 21 where the task itself reads the sink from untrusted data (a
bill's recipient, a page's address in a channel, people found by name,
a file found by listing, calendar events without a scope), which no
authority fixed before the run can separate, by construction. What
the measure argues for: a budget on an amount (send_money of
1,000,000 at once), which Renyi's budgets, counting calls, do not
express; the one extension it names. The result, its model and its
limits are docs/research/authority-gap.md; the data and the output
are tests/authority/ and CI holds the output to the script. (Claude)
AX3. The three statements written on paper: the authority bound, the
guards' explicit-flow property, the replay theorem, with their eight
assumptions named (2026-10-16 evening). docs/research/core-calculus.md:
capabilities as kinds of the tree with scopes under a partial order and
coverage as the order on pairs, the grant stack as the intersection of
main's narrowed grant with the needs of every frame below the call
(Theorem 1: every effect that happens is covered by the run's grant, and
its kind by main's needs; Proposition 1a: within a checked program a
primitive is refused only on its scope), the origins as a word and
explicit provenance as the least relation closed under the VM's rules
(Theorem 2: every guard in the provenance of an outgoing call's
arguments has a sink covering the effect; implicit flow stated as
outside it), and a run as pure steps and primitive calls answered by the
world or by the recording (Theorem 3: the replay of a recording makes the
same calls with the same answers and the same output, by induction on the
steps; the corollary is what reproduce checks). The assumptions A1 to
A8 (no ambient effect, time and random as calls, insertion order, the
standards' arithmetic, tasks in order, no observable identity, budgets
and guards decided by the state, the library's scope read from the
arguments) are each a sentence of the reference or a decision. Nothing is
mechanized; section 6 says what would be. (Claude)
AX4. The authority gap with a model in the loop: a model writing the
programs declares the ground truth's authority, 83.4% of 560 pairs
blocked against 83.2% (2026-10-16 night). The owner's word on the
channel ("你可以用oauth拉claude.exe跑?继续"): the subscription's claude -p,
the readability harness's clean channel, no API key. Each suite's tools
as a Renyi project with one Python module per tool, bound to the package
tools.<tool> so that each tool is its own kind
(tools/authority_gap/gen_tool_modules.py, tests/authority/tools/,
the record types inside each module since a declaration file resolves
no project import, the smoke programs under CI); Claude Sonnet 5.5
given the skill sheet, the cheat sheet and a note on the tools, the
task's prompt and the suite's declarations, writing the module task
with main's needs as its grant, up to three attempts with renyi
check's diagnostics fed back (tools/authority_gap/model_loop.py);
the programs checked, not run. 85 of 86 tasks clean (48, 35 and 2 at
the first, second and third attempt; travel UserTask2 not), 67 calling
exactly the ground truth's tools, 12 one it does not, 11 missing one it
calls (another route, or a program that stops where the task's actions
are in the data it reads: workspace UserTask13); under the model's
grants 467 of 560 pairs blocked, under the ground truth's kinds on the
same pairs 466: the declared grant being the call set, what the model
declares is what the ground truth declares, and the static floor holds.
The first attempt's errors led by ignore-nothing (14), unknown-type
(7) and maybe-value (6); 1,336 seconds of sampling, 72,256 thinking
tokens. What no switch of the CLI removes from the context, the
user-level CLAUDE.md of the machine's profile, is noted in the
script. The record is tests/authority/model_loop.json with the pinned
report model_loop_expected.txt, CI comparing them; the result is
section 7 of docs/research/authority-gap.md and a paragraph of the
article. Next on the track: utility, the programs run against the
environments through the bridge. (Claude, on the owner's word for the
channel)
AX5. The count corrected: AgentDojo v1 has 97 user tasks and 629
pairs, eleven combined tasks the first extraction missed; the static
measure 90.8% with the prompt's scopes, 91.1% with counts, 36 pairs the
residue (2026-10-17 night). Found while installing the benchmark for
the utility runs of AX6: its registry lists 97 user tasks of version
1.0.0 (banking 16, slack 21, travel 20, workspace 40), the paper's
count, where AX2's extraction had 86; the eleven (slack 17 to 20,
workspace 4, 19, 23, 36 to 39) are built by TaskCombinator.
create_combined_task from two tasks each, the prompt given or "Perform
the following tasks in the order they are given", the ground truth the
two in order, which an extraction reading the task classes alone does
not see. extract_tasks.py reads the combinator's calls now; the
numbers on the 629 pairs: 527 (83.8%) by kinds, 571 (90.8%) with the
prompt's scopes, 573 (91.1%) with counts, 600 (95.4%) the ceiling; the
residue 36, the 32 of AX2 and four of the combined tasks (slack
UserTask18 messages Alice, 1; slack 18 and 20 read a page named
in a channel, 2; workspace 38 deletes a file found by listing, 1), 12
where the task's sink is the attack's and 24 where the task reads its
sink from the attacker's data. AX2's entry stands as written; its
numbers are of the 86 tasks, and every document and the article carry
the 629. (Claude)
AX6. The model loop on the full set and the utility of its programs:
96 of 97 clean, 83.9% of 622 pairs blocked under the model's grants
against 83.3%, and 54 of the 96 programs do their task when run
(2026-10-17 night). The owner's choice after AX4 ("1,同时尝试3": the
utility, and the mechanization of AX7 beside it). The eleven combined
tasks sampled as AX4 sampled the 86 (slack 18 and 19, "do all the
tasks on my TODO list at tools over the benchmark's
FunctionsRuntime with the environment pickled after every call
(tools/authority_gap/utility_tools/, utility_run.py), the judge
validated on the ground truth of all 97 tasks first (utility_truth.py:
every call without error, the round trip equal), each program run with
renyi run and judged by its task's utility (utility_from_traces
for slack UserTask11): 54 of 96 (56.2%; banking 10 of 16, slack 14
of 21, travel 5 of 19, workspace 25 of 40), 91 exit 0, 3 crashes of
the program's own on data it had guessed the format of, 2 failures, one
of them travel UserTask8 calling get_current_day, which the travel
project declared and the suite does not register (the generator's
hand-copied travel list had three such tools; corrected to the suite's
28, the sample kept as taken and the defect named); by call set, 48 of
75 exact against 6 of 21 differing. The record tests/authority/
utility.json with the pinned report utility_expected.txt, CI
comparing; sections 7 and 8 of docs/research/authority-gap.md; the
article's paragraph. Next: the loop with the recording read between
writes, the utility of a program that has seen the data. (Claude)
AX7. Theorem 1 and Proposition 1a mechanized in Lean 4: formal/,
Lean core alone, no sorry, built by CI (2026-10-17 night). The
owner's "同时尝试3". A subagent wrote the project from
docs/research/core-calculus.md and grant.rs, on the toolchain elan
installed (leanprover/lean4:v4.35.0): kinds as paths with prefix as
the order, scopes an abstract decidable preorder with a top and path
scopes as the instance, covers, grants as lists, WellChecked the
static rule, a machine of frames each holding its grant with call and
prim instructions and a trace of effect and refused events, two
grant models (the stack of decision Q1 and grant::within as an
abstract sound function); authority_bound (every effect of every run
from main under [N(main), G₀] covered by G₀ and by N(main), no
WellChecked hypothesis, as the document says), authority_bound_within
(the same for within under two hypotheses about the Rust code),
refused_only_on_scope (the proposition with the host's factor named:
the refusal is on the scope unless G₀ itself lacks the kind, a
--deny, which the paper statement left implicit and section 2 now
says); 497 lines of Lean, #print axioms propext and Quot.sound
(Classical.choice for the proposition); verified by a clean rebuild
in the session. The job "The core calculus in Lean" of CI installs
elan, builds and checks for sorry. What is not modelled is in
formal/README.md and section 6 of the document; Theorems 2 and 3 are
the mechanization's next stage. (Claude, on the owner's word)
AX8. The loop: the model's programs run, read with their recordings
and written again, at most two turns; 81 of 96 do their task, the
grants where the ground truth puts them (2026-10-17 morning). The
owner chose the loop over the other items ("循环版 utility"). Each
program of AX6 ran against the environment under renyi record; the
model (Sonnet 5.5 through the channel of AX4) read the run and the
recording beside its program and the task and answered DONE or wrote
the program again, a rewritten program checked before it ran with at
most two repairs, at most two turns, the final program run and judged
once more (tools/authority_gap/loop_run.py, loop_report.py,
tests/authority/loop.json and loop_expected.txt under CI, section 9
of docs/research/authority-gap.md). The result: 81 of the 96 programs
do their task (84.4%) against 54 written once (round 0 reproduces AX6's
verdicts exactly); 27 repaired, none broken, 15 still failing (nine
kept at the model's first look and judged short of the task's rule or
reading the task from an email as data, six rewritten twice whose
steps are in a to-do list or an email the program reads and prints);
the grant changed in 9 programs, widened in 5 (four by a tool the
ground truth calls), 79 ending with exactly the ground truth's call
set; 520 of 622 pairs blocked under the final grants (83.6%) against
522 under the first and 518 under the ground truth's; 153 calls to
the model. Two tasks ran again after the first pass: slack
UserTask11, whose traces fallback the repository's utility_run.py
lacked (the lane's copy had it; ported in the same commit), and
workspace UserTask35, whose round 0 timed out at 300 seconds on the
loaded machine. The run paused once on the owner's word for the
machine and resumed; the channel's hard link to the login had broken
on a token refresh and was made again. (Claude, on the owner's word)
AX9. Theorems 2 and 3 mechanized in Lean 4: formal/RenyiCore/{Guards,Replay}.lean,
each over a machine of its own, no sorry (2026-10-17). The next
stage AX7 named, on the owner's "继续". A subagent (Claude Fable 5.1,
named this time) wrote the two files from sections 3 and 4 of
docs/research/core-calculus.md, grant.rs and value.rs, in the
lane's copy of the project, verified by a clean rebuild in the
session: Theorem 2 over values that are the record of their
computation, origin sets as predicates over an abstract guard type,
Val.origins and the least relation Prov proved equal, a stack
machine whose test drops the tested value (implicit flow reproduced,
not strengthened), guards_admit_only_sinks on every effect of every
run; Theorem 3 over an abstract state with request, pure and
apply, the live run under a world Nat → Answer, the replay by the
first unused entry with the same primitive and arguments,
replay_run and replay_output by the induction replay_tracks_live
with the book's invariant. #print axioms: propext alone for both
theorems and the corollary, none for origins_iff_prov; 468 lines of
Lean added, Theorem 1's files untouched, CI's job unchanged. The one
deviation the README names: the replay starts from the live run's
initial state, grant included, a stronger hypothesis than the
document's "a grant covering the header". What is left out is listed
per theorem in formal/README.md and section 6 of the document.
(Claude, on the owner's word)
AY. The amount budget (session 15)#
AY1. A budget on an amount: at most LIMIT of PARAMETER per UNIT,
budgets on python, PythonError.OverBudget (2026-10-17). The one
extension the authority gap argued for (AX5, section 5 of
docs/research/authority-gap.md): twelve of the 36 pairs that fit
every grant are attacks that move as much money as possible through
the task's own sink, which a budget counting calls cannot touch and a
budget on the amount bounds. The measure's own prompt+budget row
assumed at most n per run on every tool kind, the Python modules of
tests/authority/tools/ included, which the language did not allow
until this entry (python took a scope and no budget, AL1); the
document says so now. The owner's four answers, every recommended
option: (i) budgets extend to the python kinds, the count and the
amount alike, PythonError gains OverBudget(package: Text), and
foreign stays without (a C call has no boundary to refuse at); (ii)
the syntax is at most 500 of amount per run, at most LIMIT of
PARAMETER per UNIT with the limit a whole number or a decimal literal
(a decimal stands only with of), after the capability as a count
budget stands, the memory budget taking no parameter; (iii) the static
rule: the parameter is a parameter of every primitive the capability
covers among the modules declared, of type Integer or Decimal, and
at least one primitive is under it, else budget-parameter with a fix
(drop of PARAMETER, name a parameter every primitive takes, or
narrow the capability), checked once every function is declared, the
needs of every function and test of the program's own modules; (iv)
the counting: the absolute value of the argument is summed, the call
whose amount would take the sum past the limit fails before anything
leaves with the module's OverBudget (the sum untouched), and the
sliding windows of second, minute, hour and day hold with the
amount of each call stamped. A surface change under V11, one commit:
the grammar's Budget rule, the reference (section 11, appendix A),
the cheat sheet (2,996 to 2,999 tokens of 3,000, a parenthesis
shortened), the formatter, the parser's tree (Budget.parameter, the
JSON order limit, parameter, unit), the checker (effects::Budget
with its parameter, budgeted_kind, the pass check_amount_budgets
of world.rs), the VM (Counter with the parameter, its decimal
limit and the amounts stamped, exhausted reading the argument by the
function's metadata, --at-most <capability>=<limit>[ of
<parameter>]/<unit>, the MCP tool's at_most likewise), the bytecode
file (format 11 to 12, the budget record limit, parameter, unit)
and the binary encoding (9 to 10), the library (std.python), the
compiler written in Renyi (ast.ry, parser.ry with parse_budget
split in three for the body limit, effects.ry, declare.ry,
emit.ry), the conformance suite (the fixture tests/conformance/python/
gains ledger.py and ledger.ry, every function taking amount;
budget.ry spends 4, refunds 5, is refused at 1 and at -1 past 9.5
and spends 0 within it; budget_bad.ry the two messages of
budget-parameter), the rules tests of the checker and the VM's
counter test, and the guides (python.md, the skill, the runtime
guarantees, the library sketch, the research document, the article).
A replay checks a budget on an amount from the recorded arguments as it
checks a count. The static measure's rows are unchanged: an amount
budget's effect on the 36 pairs is a measure of its own, open. (The
owner, 2026-10-17)
AY2. The amount budget measured: one pair of the 36, the ceiling
unmoved (2026-10-17). The measure AY1 left open, on the owner's
"继续". Two rows added to tools/authority_gap/authority_gap.py:
+amount, the prompt+budget grant with at most A of amount per
run on a kind whose amount argument (send_money,
schedule_transaction and update_scheduled_transaction take
amount) is a literal the prompt spells out in every call of the
ground truth, A their sum (the rule of the scopes applied to the
amounts: the author writes what the prompt says), and
literal+amount, the ceiling with the counts and the amounts of
every literal. A pair is blocked by amount when the injection's
amounts of a kind sum, in absolute value, past the budget; a derived
amount against a budget is undetermined. The result: 574 of 629
blocked (91.3%), one pair more than the counts, banking UserTask15
against InjectionTask5 (a transfer of 1,000,000 where the task
refunds 10, the only task whose prompt spells its amount; the other
nine tasks with an amount read it from a file or a transaction, so no
author can write the limit); the ceiling 600 (95.4%) unmoved, since
every amount attack the scopes leave sends 0.01 with the user's data
in the subject, under any limit: there the transfer is the
exfiltration, not the theft. The residue is 35. The output's rows
carry an amount column, expected.txt pinned again, the document's
sections 3 to 5, the article's table (a column "+ amounts") and its
residue passage. (Claude, on the owner's word)
AY3. The first-run measure with the MCP server connected: one, one,
two, two, one attempts (2026-10-17). The measure the article's
conclusion named as the one to follow, on the owner's choice after
R3-1 was found decided and built. The five tasks of AW45 (the same
generator and seed, the data byte for byte the same), each given to a
fresh agent through claude -p (Claude Fable 5.1; the first measure's
subagents inherited their session's model, not recorded) with the
skill file and the cheat sheet of 9b255c6, the 0.4.0 Windows binary and
renyi mcp <task directory> connected under --strict-mcp-config as
the only sources; the prompt asks for every version to be saved before
its check, and the session counted again on the saved versions with
the binary (measure03/firstrun/analyze.py). Attempts to a clean
check: one, one, two, two, one, against one, one, one, three, two with
the skill file alone on 0.2.0; the tests and the run passed on the
clean attempt in four tasks, and in the words task the agent's own
example named a three-letter word the task excludes and took one more
version with the program unchanged; the outputs equal the programs'
of AW45 on four tasks and are the same numbers in another layout on
the logs task. The failed first attempts: query-shape and
expected on a sorted by with two keys (the fix names the query's
end; the agent sorted twice by one key) and unknown-name twice on a
test calling the module's own function qualified by the module's
name, as the cheat sheet's test example wrote it (the fix, "declare
it first", was not the fix; the agent dropped the qualifier). Every
agent called library_lookup before its first version, four to seven
times, and nothing else before it; checked through the server on one
to three versions and through the binary as a second check; ran the
tests and the program through the server once each; two to three
minutes and 18 to 21 turns per task. The agents' reports named what
they did not find: library_lookup answered "nothing matches" to a
qualified name (filesystem.list, console.print), the cheat sheet
gives the Path methods only in the skill file's passing mention, and
no spelling of an example: on a maybe value. Changed with the
measure: library_lookup splits its query on dots too, so a qualified
name finds its declaration (crates/renyi/src/mcp.rs, a case in
tests/mcp.rs, the tool's description, the tooling document and the
starter's README), and the cheat sheet's test example calls the
module's own function bare, check total_price(...), the two copies
the same. The positioning document's section 5, the article's
first-run section and table, its abstract and its conclusion carry
the measure. The lane: measure03/firstrun/ (run_task.sh, the
prompt per task, the transcripts out/*.jsonl, every attempt and the
agents' reports under tasks/, count.md, results.md). (Claude,
on the owner's choice)