docs/profiling.md records a measured baseline for the RPG2000 map scene — what the sections above currently say, which one is the bottleneck, and why moving audio to another thread does not help the frame rate (SDL_mixer already mixes on its own thread; only asset load blocks the game loop)

scripts/rpg2k/alloc_regression_check.rb boots the engine against a real game, samples mruby_type_allocs at two points in a steady window and fails if the measured per-second Array/Proc/env allocation rate exceeds a ceiling set from the RPG2000 map scene's own measured baseline — a regression guard for the per-frame object-churn fixes documented in changelog.d/, so a reverted one (or a new per-frame .each { }/throwaway-Array pattern) shows up as a failing check instead of just a quieter frame budget nobody notices

Immediate operand analyses use decoded Integers without temporary numeric Strings; see typed immediates.

Static owner dispatch recognizes boxed literal arguments as well as locals; see dynamic dispatch proofs.

Proven Ruby receivers bypass incompatible native drawing and setter guards; see dynamic dispatch proofs.

Record-hash reads propagate proven object classes through downstream class pools; see dynamic dispatch proofs.

Proven native receivers bypass incompatible Ruby dispatch arms; see dynamic dispatch proofs.

Monomorphic embedded-object calls reuse exact receiver proofs to remove class guards; see dynamic dispatch proofs.

Audited core calls reuse Fixnum argument proofs to remove redundant guards; see dynamic dispatch proofs.

Stable class/module arguments remove redundant guards in is_a? and kind_of?; see dynamic dispatch proofs.

Proven Symbol names remove redundant guards and dispatch in respond_to?; see dynamic dispatch proofs.

Nested block iterator calls use proven literal receivers to remove redundant class tests; see dynamic dispatch proofs.

The bc2cpp CI check queue starts longer checks first to reduce idle time at the end of its four-worker group; all checks keep their existing assertions.

Type checking reuses context class decoding and skips discarded C++ assembly while retaining method compilation and report diagnostics. Reusable leaf evaluations avoid repeated context dataflow without sharing root graph admission or round budgets. Prepared RBS indexes share signature lookup across methods while keeping their inference state separate. Context argument layouts and call-site keyword layouts are indexed per bytecode body while argument values remain context-specific. Settled method lookup also shares ancestor paths, simple names and Ruby owner sets to reduce allocation pressure. IR-to-RBS class-name lookups reuse the Symbol's frozen spelling instead of allocating temporary Strings; see class-name boundaries.

Context typing reuses evaluations while callee states and return masks remain unchanged within one root graph, retaining the original solver budgets.

Constant-typing fixture variants reuse the report renderer while running each compiler in its own process; the positive case still exercises the report CLI.

Enumerator call indexing follows finite Symbol name sets through branches, moves, loops and handlers; see enumerator target flow.

Legacy bc2cpp method definitions follow the actual method register through control flow; see definition value flow.

IR instruction checks share explicit bytecode construction and assertion reporting across exact-class, container shape and control-flow soundness checks. Compiler fixtures remain isolated.

Block capture metadata reuses immutable upvar and block-level indexes across compilation probes while keeping embedding eligibility and emitted registrations specific to each compilation. See ADR 0528.

A literal Array of one to eight immediates that never leaves its method is kept in a C++ buffer instead of a heap Array, when escape analysis and the element and use checks prove it. BC2CPP_STACK_TUPLES=0 disables it. See ADR 0545.

Mask diagnostics reuse immutable class-bit positions and primitive name tables while preserving registration order and private shape names; see type checking.

Numeric dataflow shares read-only first incoming states, avoiding redundant state-array copies while retaining independent updates; see numeric class facts.

Receiver unions reuse indexed class-bit members instead of scanning every registered class, with bounded decoding caches that follow lazy registration.

The host IR fact suite shares library loading across exact-class, container, numeric, return-site and origin-transfer checks with isolated case namespaces and no compiler requirement.

The IR block check suite shares one Ruby process across capture, callback, yield and block-operand checks while keeping each fixture program isolated. Host checks run even without MRBC.

The bc2cpp CI gate uses a dedicated host tools shell, generates base RBS once, and runs checks with two workers sharing a prepared fixture library. Per-command timings appear in the job summary. Related constant-typing fixtures share compatible whole-program analyses in one suite. The constant-proof suite groups declared and lexical constant checks with isolated source fixtures. Small MRBC checks use a shared fixture harness for compiler discovery, temporary programs and assertion summaries, including symbol flow, upvar walks and bytecode constant resolution. Argument, ivar and context-result checks use a shared type-check JSON runner with independent programs and feature-toggle comparisons.

Base RBS generation scans native sources with up to two worker processes by default. Both base generators accept --jobs N, including --jobs 1 for serial generation. Clang AST extraction runs only for files with registered function bodies that need return analysis.

The check-registration audit detects missing or duplicate bc2cpp registrations and distinguishes host checks from required compiler fixtures. Existing deferred audits have explicit reasons.

bc2cpp shares foreign Ruby method-name scans across closed-world proof queries, avoiding a repeated AST walk for every queried name. Its name visitors dispatch on Prism's existing Symbols to avoid temporary Strings for ordinary calls. See foreign method scanning for measurements.

Native-result proofs reuse immutable receiver-class snapshots and avoid temporary bignum membership tests.

Native base RBS scanning jumps between braces during body extraction and avoids redundant owner-pattern matches.

Behavioral installer checks share registry setup and full-core code-shape/runtime analysis while preserving separate fixture worlds, owner selections and settle policies.

The block iterator fixture reuses its baseline generation for C++ shape checks and interpreted/compiled comparison.

The opt-in RPG2k compiled-Ruby backend (RPGMAKER_BC2CPP=1) is closed-world only: it compiles the RPG2000/2003-only psp/wio/maix builds, whose only Ruby is the engine's own, and every other build (desktop, wasm, Android) stays the plain mruby build (ADR 0466). The closed world that CI's bc2cpp-build job checks is the sealed RPG2000/2003 desktop host (build_config.rb's closed build); the device builds are single-format too but are not that closed world. It generates guarded native call paths from recognized mruby core C methods. It uses exact built-in class checks and keeps ordinary Ruby dispatch for subclasses, overrides and C bodies the generator cannot prove safe. Single-argument paths substitute the compiled call argument, and public frame-independent C method implementations can be called directly when their declarations are present in mruby headers. The Hash __delete path preserves the core wrapper's call-info side effect while calling mruby's public deletion helper. A one-argument Array push send follows the exact fast branch in mruby's wrapper; a one-argument concat send uses its public Array conversion and concatenation helpers. Other arities keep ordinary dispatch. Closed-world typed calls can also resolve public methods inherited through proven included or prepended modules, with an exact receiver-class guard and dispatch fallback. Class construction lookup also follows the innermost matching class constant in Ruby lexical scope, then a proven top-level binding. See docs/adr/0177-bc2cpp-native-expression-devirtualization.md, docs/adr/0178-bc2cpp-generated-argument-expressions.md, docs/adr/0179-bc2cpp-generated-hash-delete.md, docs/adr/0180-bc2cpp-generated-array-push.md, docs/adr/0181-bc2cpp-generated-public-c-methods.md, and docs/adr/0203-bc2cpp-unique-class-names.md. On closed-world (psp, wio, maix) builds the else arm of a guard on a stable class constant (Klass.new, is_a?(Klass), Klass === x) logs a [RPG2k] guard violation and raises instead of dispatching; see docs/adr/0290-bc2cpp-guard-violation.md. The soundness contract limits which runtime errors compiled code may raise: the error mruby would raise, or a named proof-violation error that is never silent. A literal-block send (rows.each { }) to an exact Array, Hash, Range or Integer calls the compiled core iterator directly, also when the block sits inside an inlined loop body, and drops its by-name fallback when the receiver class is proven and the block cannot reach a Fiber yield; see docs/adr/0270-bc2cpp-block-core-direct-arms.md and docs/adr/0310-bc2cpp-block-arm-reach.md. A send with no block to a receiver proven an exact Array or Hash (the else of the inline [a, b].max, uniq, fetch, ...) calls the compiled core body directly when that body cannot suspend a Fiber, with no by-name send left; BC2CPP_CORE_EXTEND=0 returns the earlier output; see docs/adr/0314-bc2cpp-core-exact-direct.md. The pooled Hash#delete flow-core path (ADR 0323) is covered by the core-exact check; see docs/adr/0327-bc2cpp-flow-core-hash-delete-checks.md. BC2CPP_INTERFACE_TABLES=1 enables shared, automatically generated dispatch tables for five or more eligible exact classes, with adapters for Ruby methods, accessors and audited native entries. Short chains retain their existing form; table misses retain the checked fallback. See generated interface tables for usage and measurements. Core collection bytecode can also prove results independent of the receiver class, and exhaustive exact class sets select audited native bodies without a dynamic fallback; see core Ruby returns. Exhaustive core receiver sets also preserve collection chains: Array/Hash map results join to Array; see ADR 0348. Fixed positional core calls also preserve memo classes through each_with_object and Array results through drop; see ADR 0349. Calls that return their block's value or their receiver (RGSS::Profiler.section, tap, then) retain their result classes through checked RBS declarations; captured slots use a separate helper frame and nonlocal returns keep the method-return fallback. See Block return declarations. Sends that pass the block as an expression (reject(&:dead?), each(&block)) call compiled callees and the core block arms directly, with the block converted by #to_proc as OP_SENDB does; see &expr block sends. A literal block passed to a core body that only calls it (Array#each, each_with_index, times) is built in the caller's frame instead of on the heap; see frame-local blocks. (a..b).map { |i| ... } over Integer literals is an inlined counted loop, also inside a nested block's compiled body; see Range#map loops. A literal-block map/each on any other exact Range with Integer bounds (computed bounds, or one nested in an inlined loop body) runs a counted loop into the compiled block instead of Enumerable#collect and Range#each; see Range map/each. A shared escape analysis (tools/bc2cpp/escape_analysis.rb) answers whether the value a creation site makes leaves its frame, with callee summaries over a closed world; its first consumer lets a literal block that captures locals go to a callee outside the by-name allowlist when the callee provably keeps neither the block nor anything that reaches it. BC2CPP_ESCAPE_ANALYSIS=0 restores the earlier output. The Optcarrot benchmark measures optimized mruby and bc2cpp builds by default; OPTCARROT_DEBUG=1 selects the diagnostic build, with separate build directories for each mode. Benchmark bundles retain upstream CPU dispatch, Fiber PPU, and table initialization; workload-specific source rewrites and compiler matchers have been removed. Native probe builds use a 16,384-pointer GC gray stack; OPTCARROT_GRAY_STACK_SIZE=1024 restores the upstream capacity. The benchmark always runs on the validated sealed host (bc2cpp is closed-world only, ADR 0466). See generic IR optimization for the replacement strategy and measured performance limitations. Generated C++ is compact by default: its // proof comments are stripped; bc2cpp.rb --annotated keeps them. It is split into translation units that compile in parallel (BC2CPP_SHARDS, 4 for the compiled gems and the probe). bc2cpp compiles from a typed bytecode IR: instructions are decoded from the RITE binary into schema-typed operands, and control flow and register definitions are answered by shared BytecodeIR/Irep queries instead of per-pass text scraping, with binary fixtures that forbid text access checking the shared queries, including a reaching-definitions query (BytecodeIR.reaching_definitions) that answers through joins and loops. Method-name flow keeps visibility and removal effects precise through local aliases, branches, loops and handlers. Factory analysis follows Class/Struct factory aliases across control flow, recording all possible superclass and member names while refusing unknown uses or escapes. Named Struct layouts preserve ordered positional Symbol arguments through moves and joins; differing names retain conservative accessor definitions without claiming a fixed storage layout. Class-body scope flow requires every reaching outer scope to agree before assigning a qualified class or module name. The return and receiver class proofs read a body's exits and returned-value definitions from the same IR (return sites). IR value-class inference builds on these definitions to union literal and ENTER-created types conservatively across those paths. Declaration-aware queries also track required RBS arguments, including nullable, union and boolean types, while marking their reliance on signature contracts. Report-only checks skip cleanup of discarded C++ text; context-check variants reuse the report renderer. A guarded shared setup forks private inference variants sequentially before constructing any compiler instance. See CI report work. IR feedback extends contracts to ivars and implicit self-call returns, ranks unknown reasons by the files they hit, reports mismatches, and exports reviewable inferred return candidates, each method with a provenance comment, with type_check.rb --emit-rbs-suggestions DIR; --iterate N feeds accepted returns back for up to N rounds and writes them only once they converge. Call-result propagation supplies audited compiler results and ordinary typed-receiver RBS return bounds through joins and call chains. BC2CPP_IR_CALL_RESULTS=0 disables that reporting extension for comparison. Receiver source proofs also feed independently proven ivar reads, constants and incoming arguments into IR feedback. BC2CPP_IR_SOURCE_TYPES=0 disables this source bridge for comparison. Reporting also joins receiver-specific caller arguments, retains nullable ivar unions, and propagates container elements with contract provenance. A base class and subclasses that each have ivars share the base's embedded struct (BC2CPP_EMBED_FAMILIES=0 compares). A read of an embedded ivar that every constructor assigns skips its unset-slot test outside the construction reach (BC2CPP_SLOT_ASSURED=0 compares). Array push, element and same-length slice stores, rotate!, Integer != and Integer [] arms take inline fast paths. == and % by a constant power of two take inline Integer arms ahead of their generic paths. n[i] on a Fixnum is an inline bit read when the program's only Integer#[] is (self >> i) & 1. The compiler's own type, class and bounds guards carry branch hints (BC2CPP_BRANCH_HINTS=0 compares). hash on an exact Array of Fixnums (an Array Hash key) is computed natively with the interpreter's value. The per-element Array helpers are always inlined outside -Os builds, and their bound test is one unsigned compare. Fixnum + - * & | ^ and the compares work on the tagged word under word boxing (-DBC2CPP_TAGGED_FIXNUM=0 compares). A freeze of a core iterator's result on a literal keeps embedded ivar stores free of the frozen test (BC2CPP_FRESH_FREEZE=0 compares). A store over an existing slot roots the value it replaces, as the interpreter's register would (BC2CPP_GC_KEEP_OVERWRITTEN=0 compares). A guarded send(*table[i]) remembers each row's arm while the row stays bit-identical (BC2CPP_SPLAT_ROW_MEMO=0 compares). A devirtualized call to an embedded ivar's attr_reader reads the field in place behind a class-pointer test (BC2CPP_ATTR_READER_INLINE=0 compares). Every exact-class guard reads the receiver's class inline instead of calling mrb_obj_class (BC2CPP_CLASS_READ_INLINE=0 compares). A resumable (Fiber-yielding) method's step function keeps its registers in C++ locals between yields (BC2CPP_RESUMABLE_LOCALS=0 compares). The container shape analyses (Hash records, element layouts, sealed Hash ivars) read the IR's producers and literals. RBS self returns and mixin lookup extend nominal call chains while refusing unsigned overrides and unknown lookup paths. The type check reports untyped engine constants (TC1017, docs/bc2cpp-type-check.md, ADR 0491); no review gate fails the build on them (ADR 0522). Call-graph propagation carries complete independent argument summaries through receiver-specific forwarding chains; disable it with BC2CPP_IR_CALL_GRAPH_TYPES=0 for comparison. Contextual result summaries specialize callee returns by arguments, solve bounded recursive contexts, preserve ivars across read-only calls, and report frozen builder elements and audited native direct-form results. Frozen builder proofs follow aliases through branch joins and pure loops, refusing mutation, calls, capture and handlers. RBS feedback retains optional and keyword contracts, and candidate RBS types rest, required keyword and block parameters from complete call-site joins (BC2CPP_IR_ARGUMENT_TYPES=0 restores untyped). Generic iterator block feedback carries Array element bounds through literal block bodies and reports conditional map results. It also analyzes bounded custom yield protocols, stable immediate captures, and method-generic RBS callback contracts while retaining their provenance. Dispatch-table name sets for send(*TABLE[i]) propagate Symbol values along the same reaching definitions. See docs/adr/0236-bc2cpp-bytecode-ir.md, docs/adr/0249-bc2cpp-binary-loader.md and docs/adr/0250-bc2cpp-typed-operands-and-shared-ir-queries.md. RGSS Sprite#bitmap= and the five-argument Bitmap#fill_rect form also use frame-independent native entry points when the receiver's exact native class is proven, including inlined calls with a receiver proof; other shapes keep normal Ruby dispatch. Exact-class guards also cover Bitmap width/height, Bitmap clear/rect, Viewport rect, data objects' disposed?, display objects' visible queries, and Sprite/Viewport/Window per-frame update calls without requiring a static receiver type. Rect coordinate/dimension reads and Color/Tone component getters use their native bodies behind exact class checks too. See docs/adr/0236-bc2cpp-rgss-drawing-entrypoints.md. The frame-independent wrapper rules and supported methods are recorded in docs/adr/0242-native-wrapper-direct-calls.md. In a closed world a send to a receiver of proven class that nothing answers (PROVEN_MISS, listed on stderr; no review gate judges it, ADR 0522) is a build error, and BC2CPP_NOMETHOD_VERIFY=1 builds make a dead bc2cpp_nomethod site abort for smoke runs; see docs/adr/0275-bc2cpp-proven-class-miss-and-nomethod-verify.md and docs/bc2cpp-nomethod-verify.md. The remaining RGSS setters (x=/y=/z=/visible=/color=, Window contents=/windowskin=/cursor_rect=/active=/pause=, flash, Rect writers ...) are shared entry points too: each binding forwards to the same rgss::*_direct function the generated exact-class arms call, and in a closed world those arms let the chain's by-name fallback become a proven NoMethodError. See docs/adr/0253-bc2cpp-native-direct-entry-points.md. mruby's own natives get the same treatment where the body needs no caller frame: Array#join/#shift/#compact/#index, String#bytes and Integer#inspect are called directly behind exact-class guards, each row re-audited against the mruby sources on every compile. See docs/adr/0257-bc2cpp-native-core-direct-arms.md. String#size/#length had an exact-String direct arm too, which was removed on 2026-10-21 with the library method-name tables (ordinary dispatch again); see docs/adr/0291-bc2cpp-string-size-arm.md. Three more families of sends whose receiver is fixed by construction are replaced outright, again from audited rows: implicit-self raise (one or two arguments) and __id__, blk.call(...) on a compiled core method's own &blk (a Proc arm, and a NoMethodError for nil), and Array natives such as __svalue on a *rest parameter. See docs/adr/0274-bc2cpp-direct-kernel-and-parameter-natives.md. Those entry points are no longer written by hand: clang tooling (scripts/native/binding_split.rb report|write|check) classifies every RGSS native binding, splits the frame-independent ones into a body plus an mrb_get_args wrapper, and generates the compiler's table; see docs/adr/0263-native-binding-split-tooling.md. Where the receiver is proven rather than guessed -- a stable class or module constant (RGSS.mouse_x, Bitmap._decoder_ran?), or self of an exact class or of a class or module object's own method (the Audio._bgm_* primitives, Bitmap#_init_size) -- those entry points are called with no receiver guard and no dispatch fallback, and a constant load that follows a break inside a begin/rescue loop no longer hides its constant from that proof. The audio and tts bindings are split too. See docs/adr/0281-bc2cpp-constant-singleton-and-native-exact-direct.md. mruby's own Ruby (core mrblib, the core gems' mrblib, mruby-stringio and mruby-onig-regexp) is compiled too, by mruby-core-compiled: every method that neither names the Fiber class, builds a lambda, nor comes from an unaudited mruby-enumerator body is registered over its bytecode for the RPG2000/2003 maker, and the ones whose name no native method shares (and that take no block) also become direct call targets. The block-taking ones (Array#each, Integer#times, Kernel#loop, Hash#each, most of Enumerable, ...) sit behind a Fiber guard: while a Fiber runs (a game script, Enumerator#next) the entry hands the call to the bytecode, since a Fiber.yield inside a block cannot cross a compiled frame. Flash-limited builds (wio, psp, maix) compile none of it. See docs/adr/0264-bc2cpp-compiled-core-mrblib.md and docs/adr/0269-bc2cpp-core-block-methods-fiber-guard.md. Seven Enumerator wrappers (inspect, size, rewind, feed, next, peek, peek_values) also compile, with an unconditional root-context guard and saved bytecode inside Fibers. See Enumerator wrappers. A literal-block send from compiled engine code to one of them (list.each { ... }, h.select { ... }, xs.map { ... }) tries exact-class Array, Hash and Range arms first and calls the compiled body directly at the root context, keeping the ordinary send as its else; see docs/adr/0270-bc2cpp-block-core-direct-arms.md. When the receiver of such an arm (or of a verified core native or RGSS native entry point) is provably exact without a run-time check (a literal, a *rest array or a fresh Klass.new, in a world where no object can gain a singleton class) the class test goes, and for the frame-independent native arms the dynamic send with it; block arms keep their else for Fibers. See docs/adr/0280-bc2cpp-exact-receiver-arms.md. A return-class table (x = foo(...); x.bar, including recursion, rescue paths and block returns) and a flow over ivar slots extend that proof, and a class-guarded TYPED call whose receiver is proven exactly its guard class becomes a guard-free direct call; see docs/adr/0289-bc2cpp-return-class-table.md and scripts/bc2cpp/return_class_check.rb. [x] * n with an Integer n is an exact Array to that flow (BC2CPP_ARRAY_TIMES_RESULT=0 compares). Class pools carry the same exact classes across methods: an ivar every writer of the closed world gives one class, and an argument every visible call site passes one class to. A receiver proven nil-or-one-class (@ui = nil then @ui = {}) takes one nil? test and the exact path, and x[i]/x[i] = v on an exact Array or Hash drops its class test. BC2CPP_CLASS_POOLS=0 turns them off; see docs/adr/0296-bc2cpp-class-pools.md, scripts/bc2cpp/class_pools_check.rb and scripts/bc2cpp/guard_hint_report.rb. An eval no definition answers, and a computed instance_variable_set on the implicit self, no longer turn that ivar proof off for the whole program; see ivar proof scope. A method whose while ends in break/next and has no rescue/ensure is now modelled by that proof too (BC2CPP_NUMERIC_JMPUW=0 compares). A may-be-nil @x += 1 proves "nil raises" from the owner of each native registration on nil's lookup path, not from every file that mentions nil_class; see nil native answers. The same exact-receiver proof now reaches every arm wrapper of a send (the registered-expression chains of size/empty?/first, the tail of a POLY chain, the core_or_native fallbacks), and constants join the pools (LIST = [...].freeze is exactly an Array wherever it is read, unless a const_missing or a Ruby freeze on instances exists): 176 fewer by-name-reachable sites on the wio build; see docs/adr/0301-bc2cpp-exact-receiver-consumers-and-constant-pools.md and scripts/bc2cpp/exact_receiver_flow_check.rb. A local a block only reads or mutates (h = {}; 3.times { |i| h[i] = h.size }) keeps the exact class its method gave it inside the block, so the block's h[i] = v and h.size need no class test; BC2CPP_CAPTURED_LOCAL_CLASS=0 turns it off (see docs/adr/0308-bc2cpp-captured-local-classes.md and scripts/bc2cpp/captured_local_class_check.rb). The arguments of an initialize are joined over every Klass.new, super(...), implicit-self new and self.class.new of the closed world (BC2CPP_CONSTRUCTOR_POOLS=0 turns it off; 25 fewer index-helper callers on the wio build, see docs/adr/0313-bc2cpp-constructor-pools.md and scripts/bc2cpp/constructor_pools_check.rb). When a module or singleton defines initialize, the refusal diagnostic names its owner so the unavailable constructor proof can be traced. A klass.new whose receiver is a parameter every caller fills with class constants (the typed save records' generic table/rows helpers) no longer withdraws every two-argument constructor from those pools; BC2CPP_CLASS_OBJECT_ARGS=0 turns it off (see docs/adr/0416-bc2cpp-class-object-arguments.md and scripts/bc2cpp/class_object_args_check.rb). The arguments of every call of a setter (x=) are joined into a class pool for the ivar an attr_writer or an audited native writes and for the parameter of a setter with several definitions; a receiver those pools prove nil or one class takes a class test whose else is bc2cpp_guard_violation (BC2CPP_SETTER_POOLS=0 turns it off; 11 fewer by-name sends on the wio build, 27 before the singleton-definer arms, see docs/adr/0370-bc2cpp-setter-pools-checked-receivers.md and scripts/bc2cpp/setter_pools_check.rb). BC2CPP_SPECIALIZE=<file> (lines Owner#name param=Class, off by default) compiles a second body of a hot method under the assumption that its listed parameters are exactly those classes and puts one entry check in front of the unchanged original, so the by-name sends on those parameters resolve statically and any other argument runs the generic body (see docs/adr/0380-bc2cpp-entry-guarded-specialization.md and scripts/bc2cpp/entry_specialize_check.rb). A computed-name __send__ whose name is provably one of a finite Symbol set (a frozen constant table, a case or ?: over Symbol literals) becomes direct per-name arms with a logged violation arm instead of a by-name lookup; BC2CPP_COMPUTED_SEND=0 turns it off (see docs/adr/0303-bc2cpp-computed-send-expansion.md and scripts/bc2cpp/computed_send_check.rb). An attr_reader returns the class set of the ivar slot it reads (the class pools), so holder.thing.tag is an exact call when every definition of thing is modelled, and an Array the flow proves exact takes push/<< and the TYPED call of a core class's body with no class test; BC2CPP_RETURN_ACCESSORS=0 and BC2CPP_EXACT_CORE_ARMS=0 turn them off (63 fewer rpg2k by-name sites, all removals). With BC2CPP_SEND_ROOT_REPORT=FILE a build also tags every by-name line, and scripts/bc2cpp/send_root_report.rb ranks which producer left each receiver unproven. See docs/adr/0309-bc2cpp-accessor-result-classes-and-exact-core-arms.md and scripts/bc2cpp/call_results_check.rb. A by-name send whose receiver is not proven exact gets, ahead of its by-name else, one exact-class arm per Ruby definition of the name, when the native owner map (tools/bc2cpp/native_owner_map.rb) proves that no native registration lands on that class; core forwarders are trusted by default, BC2CPP_NATIVE_OWNER_MAP=strict refuses them and BC2CPP_NATIVE_OWNER_MAP=0 turns the arms off. See docs/adr/0397-bc2cpp-native-owner-map.md and scripts/bc2cpp/native_owner_map_check.rb. The owner scope scan searches between braces to reduce temporary allocations; see native-owner scan performance. After x.m returned normally, x is an instance of a class that answers m: a later x.n on the same value (a copy of the register, a local, no rewrite and no handler edge between) is judged against those declared classes, which drops 63 by-name else arms of the wio build; BC2CPP_CALL_FACTS=0 turns it off. Provable errors (no class answers, nil receiver, wrong argument count) were measured at 0 engine hits and are not a build error; BC2CPP_REFINE_REPORT=FILE and BC2CPP_PROVABLE_ERROR_REPORT=FILE write the reports that scripts/bc2cpp/refine_report.rb aggregates; see scripts/bc2cpp/call_facts_check.rb. BC2CPP_BLOCK_SEND_REPORT=FILE writes one row per block send (what keeps its dynamic mrb_funcall_with_block: an unproven receiver, no compiled callee, no direct entry) for scripts/bc2cpp/block_send_report.rb; the four levers it measured (SENDB call facts, Array.new { }, break/return direct entries, delete) reach 29 engine sends in all, below the cutoff, so none was built. See docs/adr/0325-bc2cpp-block-send-measurement.md. BC2CPP_DEAD_ARM_REPORT=FILE writes one row per bc2cpp_nomethod / bc2cpp_nil_receiver arm (shape of its send, whether its method can be called, rescue / probe / branch guards, receiver origin) for scripts/bc2cpp/dead_arm_report.rb: no send is a sole arm, 822 nil paths are live and unguarded (scene-lifecycle ivars and database chunks, none a bug when read), and making the provable errors compile errors would remove nothing. See docs/adr/0330-bc2cpp-dead-arm-measurement.md. BC2CPP_RECEIVER_PROOF_REPORT=FILE writes one row per engine send whose unproven receiver keeps a by-name line (where the receiver comes from, and what the line becomes when the receiver is forced to a class set, by a forked recompile that leaves the output byte-identical) for scripts/bc2cpp/receiver_proof_report.rb; 1,783 sends are unproven, the best sound slice measured (an audited native result class plus dropping the placeholder of a native no linked source defines) removes 22 by-name sends against the cutoff of 30, so none was built. Floor probes include every answering class, including sets larger than 40 classes. See docs/adr/0331-bc2cpp-receiver-class-proofs-measured-not-built.md. An audited native call graph scopes @contents and @cursor_rect poisoning to RGSS::Window, and @viewport poisoning to RGSS::Sprite/Plane/Tilemap/Window, allowing unrelated Ruby classes to prove their own slots. It removes 43 cached by-name engine sends in the Wio census (39 gain nil-receiver helper calls). Source changes or new outside callers withdraw the audit; BC2CPP_NATIVE_IVAR_SCOPES=0 disables it. See docs/adr/0332-bc2cpp-native-window-ivar-families.md. Pinned native Array-returning methods and nullable Graphics.snap_to_bitmap results join compiled Ruby returns. Proven absent native placeholders no longer spoil return tables. This removes another 16 cached sends (2,881 to 2,865); BC2CPP_NATIVE_CLASS_RESULTS=0 and BC2CPP_ABSENT_NATIVE_RETURNS=0 disable the two proofs. See docs/adr/0333-bc2cpp-native-class-results.md. Native to_s results also join Ruby returns after auditing linked implementations, the core Struct alias and String subclass freedom. This removes another 20 cached sends (2,865 to 2,845); BC2CPP_NATIVE_STRING_RESULTS=0 disables it. Regexp nil results remain possible. See docs/adr/0334-bc2cpp-native-string-results.md. Audited native dup preserves the receiver class; exact Array compact and join return Array and String. This removes one more cached send (2,845 to 2,844), without copying element or immutability metadata. BC2CPP_NATIVE_COLLECTION_RESULTS=0 disables these facts. See docs/adr/0335-bc2cpp-native-collection-results.md. Native compact, flatten, __uniq and join contracts also join compiled Ruby returns when every linked implementation and helper is audited. File.join requires String subclass freedom; uncompiled Hash transformations remain unknown. BC2CPP_NATIVE_ARRAY_TRANSFORMS=0 withdraws these name-wide facts. The current shipped Wio output remains unchanged. See docs/adr/0336-bc2cpp-native-array-transforms.md. Native bitmap= writes are scoped to Sprite/Plane families, allowing unrelated Ruby @bitmap fields to prove their own stores. Native setter values remain unconstrained. BC2CPP_NATIVE_SETTER_REPORT=path reports named contents=/bitmap= input classes and blockers; it never enables native-family pooling. Current Wio output remains unchanged. See docs/bc2cpp-native-setter-inputs.md and ADR 0337. User-method identity and forwarding calls can retain exact receiver classes using call-specific self and positional argument facts, including methods containing blocks with conservatively joined nonlocal returns; see call-context receiver results. Small exact receiver unions and inherited self families can join agreeing user-method results and call shared bodies directly; see user receiver unions. Proven Integer receivers can call audited zero-argument to_s and to_i bodies directly, including bigints; see numeric native conversions. Immediate in-bounds fresh array reads can prove primitive element receivers through a bounded literal corridor; see literal element proofs. A native arm whose receiver is already proven exact no longer needs a runtime Integer tag test on an argument the Fixnum proof covers, which removes the arm's only remaining by-name dispatch; see native arm Integer guards. Compiler opacity queries reuse finalized outside-source touch results while retaining live declaration and rebinding guards; see ADR 0534. Reaching-definition walks store a single visited register directly and promote only when needed; see visitation. Reaching-definition queries reuse immutable opaque-register key snapshots and preserve caller-owned strings; see query keys. Empty opaque-register Sets share one frozen key snapshot and the snapshot memo admits Set subclasses; see empty snapshots. Symbol-read memo lookups avoid per-query tuple keys with instruction-indexed register entries; see read memo. Factory and fragment forward-use walks share one flat work-stack core; see forward-use walk. The Fixnum proof walk borrows shared definitions instead of copying results; see shared definitions. Embedding compile probes reuse a fixed state-key list and restore caller state without temporary pairs. Eligibility probes also skip error-free register-text optimization while final emission retains it; see probe state. LCF and frozen-table mask diagnostics avoid temporary wide integer intersections; see mask diagnostics. Context call frames share frozen empty argument/keyword containers and allocate nonempty positional arrays directly; inferred masks remain fresh per call. See context frames. Type-check context binding avoids temporary argument assembly for fixed positional methods while retaining fresh masks; see context binding. Compiler call-arity predicates read decoded operands without formatting argument counts. Numeric-flow branch walks avoid temporary truthiness pairs while retaining oracle queries. Numeric flow shares unchanged load states while preserving metadata invalidation and write tracking; see ADR 0536. Numeric flow also shares unchanged scalar result states, including constants, arithmetic and index results, while retaining silent-call invalidation; see ADR 0541. Numeric flow reuses each ivar slot's last widened mask during a run, avoiding repeated wide-mask unions while preserving call invalidation; see ADR 0538. Selected core Ruby collection bodies now retain exact return classes across zero-argument calls, including literal blocks without break. This proves results of map, select, reject, partition, tally and Hash#to_h from their actual bytecode, while overrides and unknown blocks withdraw the proof. The same-tree Wio comparison removes five cached sites (2,858 to 2,853). Check-phase queries share frozen empty inputs and a constant core receiver mask; BC2CPP_CORE_RUBY_QUERY_SCRATCH=0 restores temporary input allocation for comparisons. BC2CPP_CORE_RUBY_RESULTS=0 disables it. See docs/bc2cpp-core-ruby-returns.md and ADR 0338. The same analysis follows zero-argument literal-block calls between known core receiver classes, including Array's sort_by to collect! result. Recursive specializations and unsafe blocks retain unknown results. Range's audited Array-or-nil numeric helper and actual superclass fallback also prove its to_a result, preserving the fallback for String ranges. BC2CPP_CORE_RUBY_NESTED_RESULTS=0 disables nested analysis. See ADR 0343. A constant defined by + - * / of other constants (HEADER_H = LINE_H + Window::BORDER * 2) has a proven Fixnum interval, and an RGSS::Bitmap.new(w, h) whose arguments are such constants, literals or arithmetic of them keeps neither its mrb_integer_p test nor its by-name new else (65 of the 115 sites, 69 fewer bc2cpp_send of the wio build, all removals); BC2CPP_NUMERIC_CONSTANTS=0 turns it off and BC2CPP_NUMERIC_CONSTANTS_REPORT=FILE / BC2CPP_NATIVE_INT_ARGS=FILE write why a constant or an argument is unproven. See docs/adr/0318-bc2cpp-numeric-constant-ranges-and-native-int-arguments.md and scripts/bc2cpp/numeric_constants_check.rb. A proven receiver set is judged per class (ADR 0323): a def/alias_method directly in class << <constant> lands on that object, so it is no unknown definer or installed name for instances; a name natives or outside Ruby also spell is resolved per class along its lookup path; and a flow-proven exact Hash calls the compiled Hash#delete instead of a chain over user classes. 50 fewer by-name sends in the wio engine gems (update on RPG2k::Window/Game::Interpreter, delete); BC2CPP_NATIVE_CLASS_ARMS=0 turns it off and BC2CPP_NATIVE_ARMS_REPORT=FILE (scripts/bc2cpp/native_arms_report.rb) measures the levers. See docs/adr/0323-bc2cpp-native-class-arms.md and scripts/bc2cpp/native_class_arms_check.rb. A compiled block without break/return also has a direct entry, and yields from compiled code call it without pushing a VM frame; see docs/adr/0271-bc2cpp-block-direct-entry.md. Integer#step, #upto and #downto loops over literal or proven-Integer bounds are inlined like #times; loop literals follow aliases and agreeing branch values through the shared exact-value proof, retaining the fixnum limit for every target. A bound that may be a bignum (n.upto(n + 2)) is inlined behind one Fixnum test per loop, with the original call as the else branch (docs/adr/0287-bc2cpp-step-loop-fixnum-guard.md). A method that a Fiber.new { root; :done } block calls and that reaches Fiber.yield (through while loops, those inlined loops and tiny yielding helpers expanded at their call sites) is compiled as a resumable step function over a GC-marked heap frame with numeric receiver tracing through inlined helper register offsets and slots only for actual register identifiers (diagnostic and literal text cannot inflate the frame), driven by a few lines of bytecode so Fiber.yield never has a compiled frame beneath it; a root that does not qualify stays interpreted and bc2cpp logs why. See docs/adr/0273-bc2cpp-step-loops-and-resumable-fiber-roots.md and docs/adr/0414-bc2cpp-compact-resumable-registers.md. Every explicit-receiver puts ($stderr.puts, io.puts) is one call to a shared helper that runs mruby-io's IO#puts body while the receiver still resolves to it and dispatches by name otherwise, so a redirected $stdout/$stderr or an IO#puts override behaves as in the interpreter; the reasons the guard cannot be dropped are in docs/adr/0284-bc2cpp-shared-io-puts.md. In a closed world a whole-program, by-name analysis (tools/bc2cpp/yield_reach.rb) proves which blocks, and which core iterator bodies, cannot reach a Fiber.yield: such a block carries a flag in its env, the guarded core iterators stay compiled under a Fiber while they run it, and its BLOCK_CORE_DIRECT arms drop the root-context test; the build prints how many methods, blocks and arm sites it proved. Every method a Fiber.new body can reach through any call (explicit receivers, other classes, blocks) that may yield beneath it stays interpreted. Literal Proc calls follow their own block when its creation dominates the call; unknown Proc values still follow all escaped blocks. See docs/adr/0283-bc2cpp-yield-free-blocks.md. That analysis, the block-self world scan and the block-return check read block operands, receivers and captured registers through the bytecode IR's reaching definitions (docs/bc2cpp-ir-block-operands.md). A class-body define_method(:name) { |a| ... } with a def-like block is registered as an ordinary definition, so calls to it are devirtualized; any other way of installing a method by name keeps poisoning that name. See docs/adr/0288-bc2cpp-define-method-sites.md. In a closed world === and is_a?/kind_of? are direct C calls: a receiver the bytecode proves (a class constant, an Integer constant or literal, a String/nil/true/false literal) skips dispatch, every other case/when site calls one shared tag-switch helper, and a non-class is_a? argument raises its TypeError in place; an alias, undef, Ruby definition or computed installer of the name keeps the send. See docs/adr/0293-bc2cpp-direct-eqq-and-kind-of.md. The exact-class arm for a definer class a guard chain cannot list resolves its own lookup: an attr_reader/attr_writer is a direct ivar access, a private def reached by an implicit receiver a direct call and by an explicit one the NoMethodError the VM raises, a class whose chain defines nothing the NoMethodError of the final else, and a name the RGSS natives also register is judged on the class's own chain; protected defs and names under private :x keep the send. See docs/adr/0297-bc2cpp-unlisted-class-arms.md. The RGSS getters carry audited result facts (Bitmap#width/height and Rect#x/y/width/height are small Integers, Color/Tone components Floats, Bitmap#rect/text_size an exact RGSS::Rect) that the numeric and Fixnum proofs read for a receiver proven exactly its class, so x += c.text_size(s).width loses its slow path; a zero-argument native wrapper on such a receiver is a direct call without the class-guard chain; and a send whose receiver is proven to hold only instances (and nil) ignores a def self.x definer of the same name. See docs/adr/0302-bc2cpp-native-result-facts.md and scripts/bc2cpp/native_result_facts_check.rb. A record-like Hash held in an ivar (Scene::Battle#@ui: Symbol-literal keys, read and written only as h[:key]) gives each key a whole-program class: a key that only ever holds fresh instances of one class makes @ui[:battle].step_action an unguarded exact-class call, and a non-nil Array key feeds the inlined Array loops. Any other use of the Hash (passing it on, merge!, dup, send, Marshal, a computed key) refuses the ivar. See docs/adr/0285-bc2cpp-record-hash-typing.md. Record-hash alias scans keep register IDs numeric and reuse operand register arrays. The LCF schema table (tools/bc2cpp/lcf_schema_oracle.rb) now drives a whole-program class flow (LCF_ROW_FLOW): a value proven to be a LCF::Database, a table or a row makes db[:x][i][:y] exact-class, guard-free direct calls, and a field read gets its schema class. LCF::Array2D#[]= keeps only nil, bytes or a row over the table's own schema so that a table read is always such a row. The build prints whether the proof is on (== LCF row flow ==). See docs/adr/0294-bc2cpp-lcf-row-flow.md. Constructor analysis follows source indexes through inlined calls and can directly build RGSS Table values when the native class and standard constructor chain are proven. Qualified class paths such as Namespace::Record.new retain their root when resolved from nested lexical scopes, allowing compiled initializers to use direct construction too. Array.new, Hash.new and Range.new use guarded mrb_obj_new while preserving their normal initializer dispatch. See docs/adr/0237-bc2cpp-inlined-constant-construction.md and docs/adr/0247-bc2cpp-qualified-construction.md. Constructor proofs ignore unresolved instance mixins while still checking singleton mixins that can replace class-object new or allocate; see docs/adr/0248-bc2cpp-constructor-instance-mixins.md. A call to Exception#message on a recognized rescued exception reads the same stored message and applies the same default conversion as mruby's exc_to_s; calls with unproven receivers or Ruby overrides keep dispatch. Explicit IO#puts calls use mruby-io's argv-based model only when runtime lookup still resolves to its original C body; other receivers and overrides retain normal dispatch. Division lowering has dedicated checks for integer floor division, mixed numeric operands, literal-Float receivers and fallback behavior. Bare new in a closed-world class method uses the class object's singleton owner as receiver proof, with the same constructor lookup checks. Runtime-selected LCF root types and battle scene classes now use explicit class branches for their closed-world class sets. Zero-argument to_i calls use guarded native Integer, Float and String conversions, with ordinary dispatch for other receiver types. See docs/adr/0240-bc2cpp-to-i-type-dispatch.md. Compiled module_function bodies also resolve their bare self-calls against the same module's emitted singleton copies. Symbol-cache scanning uses byte offsets and preserves Unicode text and slot order while avoiding repeated suffix scans. Lexical constant lookup shares one uncached scope helper per owner to reduce generated source size. The generator is tools/bc2cpp/bc2cpp.rb, which loads its part files in order; ruby scripts/bc2cpp/split.rb --verify REF proves that layout is a mechanical split of REF's single-file bc2cpp.rb. Statically named ivars on RData-backed classes use GC-traced mrb_value slots, while dynamic names retain the normal ivar table; see docs/adr/0232-bc2cpp-rdata-instance-variable-slots.md. Typed slots (Integer, Symbol, boolean, Integer-or-nil) are listed in the same descriptor with a kind, so instance_variable_get/set, inspect, Marshal and dup see them, and a backward register walk only feeds an unguarded optimization when the write it finds dominates the read (a join such as x = h[k] || [] no longer counts). bc2cpp also knows include Enumerable and inlines Numeric#positive?/#negative? and Enumerable#min/#max on exact Arrays and numbers, verified against the build's own core sources; see docs/adr/0261-bc2cpp-join-dominance-core-mixins-typed-reflection.md. A class-set dataflow (tools/bc2cpp/numeric_flow.rb) then proves operands of + - * / < <= > >= to be Integer and/or Float from ivars, pooled call arguments, return values, constants and captured locals, and those guarded arms call mruby's own overflow-aware numeric helpers instead of a dynamic send (bigints included); see docs/adr/0276-bc2cpp-numeric-operand-proof.md and scripts/bc2cpp/numeric_operand_check.rb. The flow avoids rebuilding equal wide masks at joins and skips register-name allocation when no captured registers are opaque; see ADR 0467. The Fixnum tier of those arms is overflow-exact (a result past the Fixnum range is a bignum, as in the interpreter, on the 64-bit and the 32-bit mrb_int targets), and the call-site proofs refuse method names a computed-name send could reach and ivars a foreign write could store a non-typed value into; see docs/adr/0279-bc2cpp-overflow-exact-fixnum-tier.md. Return-hint probes skip embedding checks when a missing outside-method scan already forces the Fixnum proof to stay empty. The else of the guarded numeric arms (+ - * / % & | ^ << >> < <= > >= -@) is one typed helper per operator that calls mruby's own bigint/numeric C function for a bigint, heap Integer or Float operand and dispatches by name only for the classes it does not own, where each site used to carry its own send; see docs/adr/0292-bc2cpp-numeric-slow-path-helpers.md and scripts/bc2cpp/numeric_slow_check.rb. In a closed world where only core classes answer an operator, the helper's by-name else is a proven NoMethodError instead (/ + * < <= > >= ^ >> round % -@; ADR 0360-0364 and docs/adr/0367-bc2cpp-expose-misc-core-bodies.md, whose the pinned fork commit (mruby-expose-misc-bodies, docs/patch-fork-tracking.md) exports the static Float#%, String#-@ and sprintf bodies the % and -@ helpers call). A closed world that compiles mruby's own Ruby also closes zero?: a Numeric runs the compiled Numeric#zero?, File/FileTest raise the File.zero? argument error, the rest is a NoMethodError (BC2CPP_CORE_COMPILED_ZERO=0 turns it off; not in the hot-only firmware builds; see docs/adr/0374-bc2cpp-zero-helper-compiled-numeric.md). A runtime class test narrows the tested variable inside the region it dominates: after x.is_a?(C), kind_of?, instance_of?, C === x (so case x when C, several whens and the else complement), x.nil?, !x, x.respond_to?(:m) and x.class == C, on the then edge, an early return/raise/next, or either side of &&, || and ?:, the receivers of x see the smaller class set and lose their guard arms or their by-name else. The narrowing stops at a rewrite of the variable, a captured variable, a call that may write an ivar, a handler edge and a loop back-edge, and is off for any Ruby definition, alias or computed install of the tested name, a singleton, a BasicObject subclass and a dynamic or outside subclass; each narrowed test checks its claim at run time and raises a guard violation when the closed world was wrong. BC2CPP_CLASS_NARROWING=0 turns it off (byte-identical to the tree without it); see docs/adr/0375-bc2cpp-class-narrowing.md and scripts/bc2cpp/class_narrowing_check.rb. Class-test caches use per-IREP Integer-indexed tables to avoid allocating a tuple key on each query; see site cache storage.

On the flash-limited builds (psp, wio and maix), the compiled-Ruby backend compiles only the profiled hot methods listed in tools/bc2cpp/hot_methods.txt. Every other method stays mruby bytecode. The generated C++ shrinks from about 4.1 MB to 0.56 MB of -Os text. Desktop, wasm and android still compile everything. BC2CPP_HOT_ONLY=1 builds the desktop binary in the same mode, and docs/profiling.md shows how to regenerate the list. See docs/adr/0214-bc2cpp-profile-guided-hot-only.md.

A proven Hash receiver's clean each_value block is lowered to a native values-snapshot loop, removing its cfunc/RProc and dynamic block dispatch; unproven receivers retain the existing fallback, while a proven receiver that changes class trips the native inliner's guard. See docs/adr/0230-bc2cpp-hash-each-value-inlining.md.

Direct module-body ivar assignments feed the existing receiver proofs, so module singleton methods such as RGSS::Input#update can use native Array#each_index loops instead of cfunc/RProc block fallbacks. Class-body and class << module ivars remain on the conservative fallback path. See docs/adr/0231-bc2cpp-module-body-ivar-layout.md.

A zero-argument Range#each block now uses the same native counter loop as the one-argument form, removing one hot-only LCF cfunc/RProc fallback. See docs/adr/0157-bc2cpp-interpreter-unlock.md.

A mandatory-arity method can now inline a one-level literal times block that forwards its own yield, removing the LCF::Array2D#each fallback while preserving break, return, exception, and missing-block behavior. See docs/adr/0157-bc2cpp-interpreter-unlock.md.

The LCF chunk-scanning loop bodies now use direct EOF/terminator loops, removing two hot-only cfunc/RProc fallbacks while preserving StopIteration#result behavior. The measured Wio LCF object text shrinks by 4,686 bytes. See docs/adr/0157-bc2cpp-interpreter-unlock.md.

The remaining LCF schema and field-index builders now use direct index loops for their fixed Array/Hash receivers, removing the last two hot-only cfunc/RProc fallbacks. A same-flags Wio-style object comparison measures 208 bytes less .text and 2,904 bytes less total object size. See docs/adr/0157-bc2cpp-interpreter-unlock.md.

RGSS::Profiler.section("name") { ... } and Profiler.frame { ... } are compiled to a direct call around the native profiling primitives instead of an RProc and a by-name block dispatch, removing 21 of the 26 hot-only profiler block fallbacks in mruby-rpg2k. A same-flags Wio-style object comparison measures 5,901 bytes less .text. A computed section name, or a body containing break, keeps the existing fallback. See docs/adr/0232-bc2cpp-profiler-section-inlining.md.

A polymorphic call with more compiled definitions than the 16 an inline class-check chain allows (update, with 19 classes on the full build) finds its compiled method in one lookup table that every call site of the name shares. Any other class keeps ordinary Ruby dispatch. See docs/adr/0227-bc2cpp-poly-table-dispatch.md.

--render_fps=N caps how many of every 60 Graphics.update calls actually repaint the screen — 30, 15 or 10 redraw the screen that many times a second instead of 60, to cut rendering CPU/GPU work and the memory bandwidth it costs on constrained hardware (handhelds, older phones, the PSP/Wio Terminal ports). Game logic, Graphics.frame_count, animation timers, message speed and Wait all keep running every call at the normal rate — the game plays and times identically at every setting, it just visibly updates less often:

./rpg_maker_clone --render_fps=30 --game_dir path/to/game

Defaults to 60 (every frame renders); values outside 1..60 are clamped with a warning.

For RPG Maker 2000/2003, a low --render_fps also shrinks the map scene's decoded-bitmap cache budgets (named graphics and toned-picture variants) by roughly the same ratio, evicting the least-recently-used entry sooner in exchange for real RAM saved on a constrained device — see docs/adr/0063-render-fps-scaled-bitmap-caches.md. No effect at the default 60.

Read-only IR consumers borrow frozen reaching-definition cache entries while public callers retain independent mutable results.

Constant typing shares compatible positive and unknown-receiver fixtures while retaining separate worlds for method redefinitions; see CI fixtures.

The URL and proxy fields are remembered across reloads and mirrored into the address bar as a ?url=…&proxy=… query, so the page is bookmarkable and shareable — opening a link with a ?url= auto-loads that project. (Values are also kept in localStorage, so a plain reload restores whatever was last typed even without a query string.)

Save data survives a reload. Every maker's save file is mirrored into the browser's IndexedDB (via Emscripten's IDBFS), keyed by the loaded project, and copied back before that project next starts — Continue/Load sees the previous session's progress even though /game itself is rebuilt from scratch on every page load. See docs/adr/0064.

A project can still be baked into the page at build time with -DWASM_GAME_DIR=/abs/path/to/game; that page auto-starts the game with no interaction (and the loader is skipped).

The page draws an on-screen keypad (D-pad plus OK/Cancel/Dash, the L/R shoulders and the A/X/Y/Z buttons) beneath the canvas, so the game is playable by touch or mouse without a physical keyboard; the keyboard keeps working too.

The canvas shows a live FPS/CPU overlay in the top-right corner (LVGL's built-in performance monitor), the same one the Android build already draws — a browser tab has no title bar or terminal to show --profile's output (see "Profiling" above), so this is the only on-screen way to see frame rate here. Its CPU% is fed from a custom idle measurement (src/main.cxx) covering the whole frame — Ruby game logic and input included, not just LVGL's own render step, which is all LVGL's stock reading sees and badly understates real usage (see include/lv_conf.h). Press F3 to hide or show it, so it does not have to sit over the picture during normal play; the key is not bound to anything else in the browser build.

Scaling is the page's job, not the engine's. The canvas holds one pixel per game pixel (320x240 for RPG2000/MV, 640x480 for XP) and the page sizes the element in CSS — the whole-number zoom the screen has room for (2x for a 320-wide game on a desktop), filling the width on a screen too narrow for it, with image-rendering: pixelated to keep it crisp. The frame is therefore presented 1:1 and the browser does the upscale, instead of the software renderer stretching every frame into a doubled window.

CI publishes this page: pushes to master deploy it to GitHub Pages, and commenting /preview on a pull request builds that PR and posts a Cloudflare Pages preview URL back on it. See docs/deploy.md for the one-time repo setup (Pages source + Cloudflare secrets).

bc2cpp CI enables CRuby's YJIT for host analysis and code generation, including nightly fixture and mutation checks. Mutation workers flush Ruby failure output so the pool can stop caught mutants promptly. See the CI guide for verification and local comparisons.

bc2cpp initializes argument registers directly and removes unreferenced nil-only register declarations from ordinary compiled methods and blocks (see generated register declarations). The declaration scan streams canonical register matches without allocating a string for each occurrence. A liveness pass over the emitted instruction texts also drops dead register copies and constant loads and propagates plain copies (BC2CPP_REGISTER_FLOW=0 turns it off; see the same page). Register-read masks accumulate during text scanning without intermediate register lists.

bc2cpp binary decoding shares source-file lookups between filename and line metadata and avoids per-instruction enumerator allocations. The binary-loader check compares source locations and instructions with mrbc (see CI documentation).

Manual bc2cpp nightly runs can compare decoded-tree reuse for repeated worlds, restoring private objects before each analysis. It defaults off because cold population can slow a parallel build. See ADR 0411.

bc2cpp test builders run mruby prerequisite tasks concurrently with bounded Rake workers, reducing cold fixture and width-build setup time. See the CI guide.

bc2cpp reuses repeated bytecode dataflow queries during analysis and code generation; bounded caches also reduce repeated work in fixture tests. See ADR 0409. Its independent test oracle shares immutable definition sets and avoids duplicate queued instructions; see the CI guide.

CI also runs the width-sensitive bc2cpp checks on a 32-bit-mrb_int and a no-bigint mruby (the Emscripten/Wio/PSP widths) and listens for merge-queue runs; docs/ci.md lists the repository settings the owner has to enable for the queue.

The patches ride in their own timidity*.data packages rather than the runtime's index.data, split to keep every published file under Cloudflare Pages' 25 MiB per-file limit so PR previews can deploy (scripts/pack-timidity-data.py, ADR 0031). Serving the page means serving timidity.js and those packages alongside index.*

More resilient audio timing in the browser. Unlike the desktop build, where SDL_mixer mixes on a real OS audio thread (see "Profiling" above and docs/profiling.md), the Emscripten build has no such thread — there is no -pthread/-sUSE_PTHREADS or -sAUDIO_WORKLET here, so the browser's ScriptProcessorNode-based audio callback runs on the same single JS thread as the game loop. The frame-pacing wait Graphics.update does every frame to hold 60fps used to be a blocking OS sleep, which starved that thread and showed up as delayed/glitchy audio; it is now left to emscripten_set_main_loop's own non-blocking scheduling instead (src/main.cxx, mruby-rgss/src/lib.cxx). Separately, the mixer's output buffer is now larger in the browser build (src/sdl_audio.cxx): a ScriptProcessorNode callback that fires late does not resync to the clock, it just stays that late and compounds on every further stall — sustained input like holding a direction key is exactly the case likeliest to trigger it — so more buffer headroom trades a little fixed latency for much better resistance to that failure mode. See docs/profiling.md for why this needs a bigger buffer rather than a smaller one, and what a more complete fix (AUDIO_WORKLET) would take.

RPG2000/2003's message window can read itself aloud, in Zundamon's (ずんだもん) voice, opt-in via --zundamon_tts: each Show Text/Show Choices page's plain text (control codes already expanded — actor names, variables) is spoken as the page opens, through a bundled offline VOICEVOX CORE synthesis stack (RGSS::Tts) rather than a separate VOICEVOX Engine process or any network access at play time. The stack (~90 MiB: VOICEVOX CORE, its ONNX Runtime, the Open JTalk dictionary and Zundamon's voice model) is downloaded rather than committed:

./scripts/download/voicevox-zundamon.bash
./rpg_maker_clone --zundamon_tts --game_dir path/to/game

--zundamon_tts_style picks among Zundamon's four bundled styles (3 ノーマル/normal — the default, 1 あまあま/sweet, 7 ツンツン/curt, 5 セクシー/sultry); --zundamon_tts_speed/_pitch/_intonation/_volume tune the AudioQuery scale factors VOICEVOX itself exposes, each defaulting to VOICEVOX's own neutral value. Reaching an entirely different VOICEVOX character needs its own downloaded voice model, which the download script above does not fetch. With nothing downloaded (or on a build this feature does not cover — desktop native only; see docs/adr/0046-zundamon-message-narration.md) the flag logs why and the game runs exactly as it would without it (RGSS::Tts.available?). Audio generated this way must be credited "VOICEVOX:ずんだもん" — see assets/voicevox/README.md