NishiLang vs the Language Field

Nishi MEASURED Stabilizer-validated 2026-05-20 [stabilizer2013] (bench/paired_native_microbench.tsv) vs gcc -O0; root cause stack-machine x86-64 backend, regalloc wired into RISC-V only [poletto1999]; peer columns = commonly documented ranges vs C. RE-MEASURED 2026-08-14 on the CURRENT compiler (674,866 B, eleven promotions later) with bench/nx_lang_h2h.sh, an identical bounds-checked hot loop where all four arms must print the same checksum or the run is void: gcc -O2 unchecked 2,270 us . Rust -O checked 5,041 . NishiLang checked 10,237 . NishiLang UNCHECKED 4,581. So against gcc -O2 the unchecked lane is 2.02x and the checked lane 4.51x. THE FINDING THAT RE-RANKS THE PERF WORK: NishiLang unchecked (4,581) lands within 9 percent of Rust CHECKED (5,041), i.e. the raw codegen is already at the checked-language tier, while the bounds check itself costs 2.23x on this loop. That first pointed the next rung at proving checks away -- and then READING THE EMITTED ASSEMBLY for one checked access moved it again, which is why the assembly is quoted in the ledger rather than summarised. Per iteration of a bounds-checked accumulate loop the backend emits roughly seventeen instructions, of which the check is two compares and two branches while SIX are pure memory traffic: the loop counter lives in r12 and the accumulator in r13 for the whole loop -- register allocation demonstrably worked -- and the emitter STILL spills both to stack homes on entry and reloads the counter twice more, once for the high check and once for the address computation, from a register that never changed. So the dominant cost is not the check and not the missing phi nodes (the two loop-carried values are already in registers); it is that THE BACKEND DOES NOT CONSUME THE REGISTER ALLOCATION IT ALREADY COMPUTED, materialising every value through its stack slot at every use. That is now the ranked number-one perf rung, it is witness-backed by runtime/nx_probe_bchk_asm.nx rather than argued, and it explains why round 3's assembly dump reached the same conclusion in July and was read as a phi problem instead. Stated honestly: this is a DIFFERENT benchmark and a DIFFERENT baseline from the 3.65x figure above (that one is vs -O0 on the paired microbench and has NOT been re-run), so the two numbers are not comparable and neither refutes the other

Rust ~1xZig ~1xGo ~1.2-2xSwift ~1.1-2xKotlin ~1-3x JITTypeScript JIT variesPython ~10-100x interpC 1x barElm n/a (JS)OCaml ~1-2xHaskell ~1-3x

langintel- planes: 669 rust I-unsound + 982 LLVM miscompiles, injection-scanned 0/1651, classified into 26 ranked capability axes; top demand compiler-miscompile-codegen 638 = the build order (SSOT knowledge/store/langintel-requirements-)

Rust tracker onlyZig tracker onlyGo tracker onlySwift tracker onlyKotlin tracker onlyTypeScript tracker onlyPython tracker onlyC tracker onlyElm tracker onlyOCaml tracker onlyHaskell tracker only

Nishi measured 2026-08-13: 188 B return-42 ELF with --no-crash-guard (the deliberate minimal lane); the crash guard is DEFAULT-ON since 2026-08-13 pm and costs +4.9 KB (guarded return-42 = 5,105 B) -- still half of Zig's ~10 KB and 60x under C's typical static; peers = documented typical hello-world static/stripped order-of-magnitude

Rust ~300 KB strippedZig ~10 KBGo ~1.5-2 MBSwift ~500 KBKotlin n/a JVMTypeScript n/a JSPython n/a interpC ~16 KBElm n/a JSOCaml ~1 MBHaskell ~1 MB

Nishi counts only true native ELF backends on this axis (x86-64 + RV64 in one sovereign binary); wasm is deliberately NOT counted here -- not a native backend; Zig 0.15 ships its self-hosted x86 backend [zig0151]; Go owns its backend

Rust LLVM (ext)Zig LLVM + own x86Go own, 12+ targetsSwift LLVMKotlin JVM + LLVM nativeTypeScript JS emit (non-native)Python bytecode VMC gcc/clang allElm JS emit (non-native)OCaml own native + byteHaskell GHC NCG + LLVM

Rust borrow checker is the bar [rust-ownership] yet 669 I-unsound bugs banked = even the leader leaks (our oracle lane measures it); Nishi raw pointers SIGSEGV -- filed; equiv net GREEN 2026-08-05 = the enforcement lane is OPEN (standing rule: every nx_cc change passes nx_cc_equiv_gate before promotion)

PART, measured 2026-08-23 on the live compiler: typed arrays [N]T and slices []T are bounds-checked BY DEFAULT (NX_BOUNDS_CHECK_LIVE, the LB4 rung, cost measured 2.23x on the checked hot loop) and the raw-pointer half -- the READ-TO-NUL over-read class -- traps only under the --ptrprov DECLARED MODE (LN3, shipped 2026-08-19: exit 71, CWE-125 read and CWE-787 write legs, a provably out-of-range constant index refused at parse time; nx_boundscheck_gate 11/11 GREEN re-run 2026-08-23 after the LN2 promote). Default stays OFF for raw pointers until the per-class ratchet flips it after a clean corpus census, which is the distance to Yes. CISA memory-safe roadmap (banked langbug.q 2026-07-10) [cisa-memsafe] puts this class at the top of what bites C; our 2026-07-08 READ-TO-NUL over-read was exactly this class in the wild

Arena no-free doctrine mitigates in practice (nothing frees) but no checker ENFORCES it; Rust the bar; 24 Pin-class bugs in the oracle corpus show the hard tail

PART, SHIPPED 2026-08-23 as the --chkarith DECLARED MODE (LN1): an i64 add, subtract or multiply whose result leaves the i64 range TRAPS with exit 72 naming CWE-190 and the fix, MIN times minus-one traps the same way instead of SIGFPE, __wrap_add / __wrap_sub / __wrap_mul are the exempt intent-declaring forms, and a constant overflow is REFUSED at parse time (capability=checked-arith-const-overflow); nx_chkarith_gate 17/17 GREEN live (passed 9/17 against the banked pre-LN1 compiler: exactly the mode teeth), nx_cc_equiv_gate 10/10 plus selfhost GREEN, default builds byte-identical. Under the default i64 still wraps silently, and the default stays OFF until the per-class ratchet flips it after a clean corpus census -- that flip is the distance to Yes. FIRST RUNG SHIPPED 2026-08-13 on the neighbouring silent-wrong-value: a CONSTANT shift count outside the result width is now REFUSED at compile time, because the processor keeps only the low bits of the count and the program would otherwise compute a different shift than the one written -- MEASURED before the fix: 1 shifted left by 70 compiled clean, ran, and returned 64 (70 becomes 6). The refusal names the legal range, the fix, and capability=shift-count-range; runtime counts and in-range counts are gate-controlled to keep compiling, since an over-eager check would refuse the overwhelmingly common shapes. CORRECTION, measured not remembered: this cell's older note claimed an over-shift 'blanks the emitted .s' (2026-07-06) -- STALE, it compiles and returns the masked value. Zig safe-mode + Swift trap-by-default + Python bignum lead on the overflow half; Go wraps by definition

PART, SHIPPED 2026-08-23 as the --optenforce DECLARED MODE (LN2): a dereference of a pointer-typed local not proven non-null on its path is REFUSED at parse time naming the local and the rule (capability=option-enforce-unwrap); proof comes from the idioms this corpus already writes (if p != 0 then-block, the early-exit if p == 0 return/break/continue/sys_exit, the else-block, while p != 0, nx_assert_ptr) and a reassignment re-derives the bit, so a stale check does not survive p = call(). Declared floors, each measured against the stdlib: parameters and module statics trusted, sys_mmap results non-null by the allocator contract, int-to-pointer casts trusted, chained derefs through fields or calls unchecked (bind to a local first). nx_optenforce_gate 14/14 GREEN live (hazard refused at p.val, the reassign witness refused, the nine-idiom positive control compiles and runs under the mode with byte-identical asm so the mode emits no IR), 9/14 against the pre-LN2 compiler; nx_cc_equiv_gate 10/10 plus selfhost GREEN. Sentinel-zero-as-null is our recurring P2 meta-class; Option and Result EXIST in the stdlib and the mode now enforces the checked path for locals; default stays OFF until the per-class ratchet flips it after a clean corpus census -- the distance to Yes. Elm ships no null at all

Swift 6 strict concurrency joined Rust Send/Sync as the 2026 bar; Go ships a runtime race detector; Nishi pool is real (7x measured) but untyped

54 poison/undef oracle bugs banked (demand rank 3); C UB is the negative bar; managed languages define semantics; Rust unsafe still carries UB (miri checks it). FIRST RUNG SHIPPED 2026-08-13, chosen by MEASURING the edges rather than by taxonomy: the compile-time-decidable UB shapes are being refused one at a time with the capability voice -- constant out-of-range shift counts land first (silent masked-shift, measured 1<<70 = 64 pre-fix), and the runtime traps that remain now SPEAK instead of dying silently (a divide-by-zero SIGFPE prints the arithmetic-trap diagnosis and the divisor advice; that fix-line classifier was itself corrected the same day after it wrongly printed the null-pointer hint on an arithmetic trap -- a wrong hint is worse than no hint). Still No overall: the class is not closed until poison/undef semantics are DEFINED, not merely refused case by case

Payload ctor + match probes re-verified run-exit=0 2026-07-09; no exhaustiveness yet -> lint rung; Elm/OCaml/Haskell ADTs are the bar; Go lacks sum types

SHIPPED 2026-08-05, bite-witnessed refuse+accept through /api/build (nx_parse: non-exhaustive match: 2 of 3 variants handled) with the witness in-tree (nx_probe_exhaust_live.nx): EnumEntry now records n_variants and parse_stmt_match counts DISTINCT discriminants (values not arm positions, so duplicated arms cannot fake coverage and explicit = N variants stay correct); gated nx_cc_equiv_gate 10/10 + selfhost -- which doubled as the estate backfill census (zero non-exhaustive matches, so no amnesty was needed) -- and promoted through promote_toolchain canary GREEN. DIAGNOSTIC PARITY-PLUS with Elm (the reason this cell moved to Best): the message CITES THE LINE, NAMES THE ENUM, and NAMES THE MISSING VARIANTS -- nx_parse: line 1118: non-exhaustive match on enum ExhColor: 2 of 3 variants handled -- add an arm for: Blue (no new storage: variant names already live as Enum::Variant module consts). PLUS a second check Elm/Rust-class but ours by construction: UNREACHABLE ARM refusal, citing BOTH lines -- nx_parse: line 1121: unreachable match arm ExhColor::Red -- already handled by an earlier arm of the match at line 1118. Declared narrowness: discriminants outside 0..63, or an unresolvable enum, decline the verdict rather than guess

COMPILER-ENFORCED and bite-proven live 2026-08-05 via /api/build, both refuse+accept directions witnessed in-tree: ARITY (call arity mismatch, forward refs via pre-registered stubs; nx_probe_arity_live.nx) + POINTER-into-INTEGER types (argument type mismatch, the sev-8 silent-zero shape, 0 measured false positives; nx_probe_ptrint_live.nx) + duplicate-definition guard. FULL BOTH-DIRECTION TYPE REFUSAL SHIPPED 2026-08-05 after TWO root fixes, each gated (nx_cc_equiv_gate 10/10 + selfhost) and promoted through the canary toolchain door: (1) the trailing `as T` cast MUTATED THE OPERAND in place, so any local ever written `p as i64` read as INTEGER at every later call -- a silent wrong-type class for every casting caller; cast now emits a typed identity (equiv gate 10/10 + selfhost, toolchain-promoted canary GREEN, witnesses nx_probe_castmut_live/2). and (2) POINTER ARITHMETIC DECAYED TO i64, so the corpus idiom emit(out + o, cap - o) handed a POINTER the parser believed was an INTEGER -- that was the whole 57/70 residue, i.e. the check had been RIGHT about a type the parser had already lost. Named by the equiv gate's newly-captured compiler stderr (a gate that reports a failure without its diagnostic makes the failure unactionable). BOTH DIRECTIONS now refuse, bite-witnessed refuse+accept on the live compiler (nx_probe_intptr_live.nx / nx_probe_ptrint_live.nx). Integer LITERALS stay exempt by design (sentinel/null idiom); fn-pointer calls remain unverifiable by name; arity census crons daily

Full monomorphization port landed (parse.nx instantiate_generic_n); Rust traits + Haskell typeclasses lead depth; Go type sets since 1.18 [go118]

Explicit-declaration is a named stance (reads better at audit time) yet stays a No under less-than-SOTA-never-design until measured as an exceed

OCaml 5 effect handlers + Haskell monadic IO + Elm purity are the frontier; watch-class for the substrate

nx_chan Vyukov MPMC + ring-arena pool 7x measured (2026-07-06 gate); goroutines the industrial bar; Zig async dropped in 0.15 pending redesign

Swift task trees + Kotlin coroutine scopes = the 2026 design bar; Python TaskGroup 3.11; Go errgroup is a library

Explicit threads + channels = no function coloring by construction; OCaml effects give colorless concurrency; Rust/Swift/Kotlin/TS/Python all carry the async split

Option/Result exist in the stdlib unenforced; the estate-wide refusal-with-reason-and-fix convention is real but convention, not type system; Zig error unions + errdefer; Swift typed throws

CARET + DID-YOU-MEAN ARE SOVEREIGN NOW (2026-08-05), bite-witnessed: nx_parse: line 1116: call to undefined function 'dym_helpr' -- did you mean 'dym_helper'? (bounded Levenshtein over the module function table; witness nx_probe_dym_live.nx). It stays SILENT when nothing is near -- a wrong suggestion is worse than none. Every enforcement diagnostic shipped today cites a LINE and two cite BOTH lines (duplicate definition; unreachable match arm). CARET SHIPPED the same day and bite-witnessed end to end: nx_parse: line 1116: call to undefined function 'dym_helpr' -- did you mean 'dym_helper'? / then the offending source line / then ^ under the call. Plumbed ADDITIVELY (a module static the driver fills; unset = no snippet, never a wrong one) so no parse_module caller changed. FIRST ATTEMPT PRINTED THE CARET UNDER THE WRONG LINE (P.pos had advanced past the call, landing on the NEXT statement) and was corrected before promotion by anchoring on the call's own token -- A CARET THAT POINTS AT THE WRONG LINE IS WORSE THAN NO CARET. Arity + undefined-call diagnostics now share that anchor. MULTI-ERROR RECOVERY SHIPPED 2026-08-05 late (gate 10/10+selfhost, canary GREEN, witness nx_probe_multierr_live.nx): 12 semantic sites (undefined call/ident, call arity, arg types, unknown type, non-exhaustive match, unreachable arm, duplicate definition, const-before-decl, bad assigns) now note-and-continue, closed by a hard end gate -- nx_parse: N error(s) -- no output emitted -- so a broken build reports EVERY error in ONE compile and recovered (poisoned) IR can never reach codegen; parser-desync sites stay fatal BY DESIGN (past a desync every diagnostic points at innocent code); cap 20. DID-YOU-MEAN NOW COVERS BARE IDENTIFIERS (witness nx_probe_dym_ident_live.nx: line 1117: UNRESOLVED identifier 'countr' ... -- did you mean 'counter'? plus source line + caret; suggestion pools = live locals window + module consts + function table, ZERO new indexes; the UNRESOLVED diagnostic also gained its line number + caret via the one-slot-back token anchor, verified by emitted bytes). TYPE-NAME DYM TOO (same evening, witness nx_probe_dym_type_live.nx): unknown type name 'TypoPont' (not a primitive, struct, or registered type alias) -- did you mean 'TypoPoint'? -- pools = declared struct table + active generic type params; primitives deliberately excluded (2-4 char names make distance-1 suggestions noisy) and the narrowness stated in-source; gated 10/10+selfhost, canary GREEN. THE 5W+H / ELM-CLASS VOICE IS LIVE ON THE UNDEFINED-NAME FAMILY (2026-08-06, three operator escalations in one night: metadata notes -> quoted declarations -> the full invested logging standard, nxc2-5wh-substrate 2026-04-29 + elm-class-friendliness CARDINAL 2026-05-07). A missing name now reads, verified by emitted bytes end to end through /api/build diag_errors: error at line 1118: I do not know the name 'dym_helpr' -- it is called here, but nothing in this program defines it. / source line + caret / why the build stopped: this name has no definition, so the program would have nothing to run here -- building on would ship a crash or a wrong value at this exact spot. / closest defined name: 'dym_helper', declared at line 1116: + the declaration QUOTED / fix: if 'dym_helper' is the one you meant, change the spelling to match it; if not, define 'dym_helpr' yourself or import the file that provides it. / error: the build found 1 problem(s), listed above, and wrote no program. Rubric self-score ~24/25 (WHAT 5 WHERE 4 WHY 5 HOW 5 NO-JARGON 5; the missing WHERE point is the file name -- the per-file rung). Internal organ prefixes are GONE from these messages. SHIPPING THE VOICE ALSO EXPOSED A STACK TRUNCATION: hostctl echoes only the last 600 bytes of the builder's capture, smaller than ONE 5W+H diagnostic -- the mgmt API now reads the builder's full capture directly, so the API surface carries the whole message. Suggesters are silent stashers; one printer owns the voice; locals resolve by nearest-above scan (shadowing-correct); a const names its evaluated value. REMAINDER CLOSED ON THE HIGH-FREQUENCY SITES (2026-08-13): call arity, reassigning a 'let', duplicate definition, and reserved-keyword-as-name -- the four mistakes any author arriving from another language makes first -- now speak the same what/why/how voice as the undefined-name family, all reported in ONE compile (arity now names the CONSEQUENCE: a missing argument is not empty, the callee reads a leftover register, so the wrong value moves when unrelated code moves and the crash never points back at the call). These are USER ERRORS and deliberately carry NO capability= slug, which is what keeps the demand journal an honest signal of missing CAPABILITY rather than a log of typos. Still on the old organ-prefixed voice: exhaustiveness, unreachable-arm, const-before-decl and the desync sites (anchored by the diag_errors dual-anchor until their rewrite). RUNTIME crash diagnostics (2026-08-13, rungs 1a+1b BOTH shipped same day): SIGSEGV/SIGBUS/SIGILL/SIGFPE now print instruction + fault addresses in the same 5W+H voice and STILL die by the original signal (wait-status unchanged) -- and this is DEFAULT-ON FOR EVERY PROGRAM: the driver appends the self-contained guard and the parser injects the arming call at main entry (--no-crash-guard opts out; measured +4.9 KB per binary; run-behavior byte-equal across the whole equiv corpus). Stack overflow is covered via a 32 KiB alternate signal stack, and the fault classifier names UNBOUNDED RECURSION when the touched address sits at the stack boundary instead of misdirecting to the null-pointer hint. Witnesses prove the EXACT planted fault address prints, the bare-program injection, the opt-out silence (attribution control), and the overflow diagnostic. The resolve loop is now ONE COMMAND: every crash diagnostic prints its own program path (readlink /proc/self/exe) plus the exact nx_addr2line invocation -- the shipped CLI (now REGISTERED over MCP; it was PROMOTED-UNREGISTERED, a real binary nobody could call) prints file:line AND the function name on a -g build and honestly REFUSES (rc=4) without .debug_line. In-process resolution is deliberately NOT embedded: it would drag the DWARF decoder into every ~5 KB guarded binary; the one-command offline loop is the design, stated on the diagnostic itself. CAPABILITY-LIMIT VOICE (2026-08-13 night): when the honest answer is NOT-POSSIBLE, the diagnostic now says whether that is a design stance or a roadmap gap, teaches the supported way, and stamps a greppable capability=<slug> marker at the moment of friction -- (1) a float value into an INTEGER binding used to COMPILE CLEAN and silently store the raw IEEE-754 bit pattern (measured: 1.5 became 0x3FF8000000000000, no diagnostic); EVERY store site -- let, var-init, plain assignment, pointer deref (*p = 1.5), array subscript (a[i] = 1.5), and struct field (s.f = 1.5) -- now refuses through ONE shared guard whose destination type is the pointee/element/field, so float MEMORY stays fully legal (*f64 deref-store control gated) while every integer destination refuses; the first cut covered let only and re-checking the published claim caught the divergence (the multi-error compiler reports all three memory sites in a single build), teaching Q14 fixed-point and leaving the float lane reachable via : f64; (2) the parameter-cap refusal teaches the struct-pointer idiom instead of naming IR internals; (3) the crash guard's pointer branch teaches CHECKED access ([N]T and []T refuse out-of-bounds with a message). The slugs feed the AI-friction transcript mine, so real user friction re-ranks the public roadmap -- the same loop that chose every rung shipped today. HONEST REMAINDER: line numbers are EXPANDED-source lines (per-file mapping is its own rung) and rustc/Elm still carry error codes, --explain prose, and structured/JSON output we do not. Elm + rustc the bar [elm-errors]

rust-analyzer, gopls, IntelliJ, TS server lead the field; we ship none -> rung

SHIPPED 2026-08-23 (LN9, nx_srcfmt, symbol srcfmt_emit): one canonical style with no options, the gofmt shape, and the style was MEASURED from the whole corpus rather than chosen (18,801 files, 2.97 M lines: 4-space indent 2,216,007 vs 9,644; brace on the opening line 179,575 vs 2; joined else 33,968 vs 5,444; struct field type columns aligned in 1,340 of 1,712 multi-field runs) -- a census verb prints the same numbers from the same scanner so the rule and its ruler cannot drift. Comments, string literals and @-directives are preserved byte for byte, and a token-stream ORACLE built on the compiler's own lexer refuses any output whose tokens differ from the input, so nothing is ever written unless the oracle agrees. Proof over the FULL population, not a sample: 18,809 of 18,815 sources format idempotently (fmt(fmt(x)) == fmt(x), 0 exceptions, 0 comment losses) and build to byte-identical assembly; the 6 remaining files use @for range expansion or @macro gensym substitution the formatter does not model and are REFUSED (exit 3, nothing written) -- the declared floor. nx_srcfmt_gate 13/13 GREEN live, bite-proven both ways (alignment killed -> 12/13 RED; oracle broken -> 12/13 RED). The corpus itself is NOT reformatted yet: applying the formatter tree-wide is a separate decision. gofmt set the standard; zig fmt, swift-format, prettier, black follow.

We rebuild whole modules every time; every peer caches

DWARF v5 .debug_line at STATEMENT granularity, OPT-IN via -g: the compiler emits .file/.loc, nxasm accumulates (address,file,line) and encodes the line program, and the ELF carries the section behind a section-header table. PROVEN END-TO-END 2026-08-07 by nx_dwline_e2e_gate 14/14 -- it drives the real nx_cc_sovereign + nxasm_x86_main, and recovers source lines 5 and 9 from real addresses in the emitted ELF; its load-bearing tooth is the negative control that WITHOUT -g there is no .debug_line at all, so the measured 168 B minimal static binary is untouched. Encoder and decoder are independent organs sharing no code and agree on 13/13 (nx_dwline_roundtrip_gate), and GNU readelf resolves the same addresses, so third-party gdb/addr2line interop is real rather than asserted. STATEMENT granularity landed 2026-08-07, MEASURED AT CORPUS SCALE against the previous build rather than asserted on a fixture: THE ENTIRE RUNTIME CORPUS -- all 11,379 files attempted, 11,121 built (97.7 percent), covering 1,725,477 functions. This is a census, not a sample: no curation, no window, nothing excluded. The 259 files that did not compile are PRE-EXISTING failures, not caused by this change -- in every window where both compilers ran, the built counts were identical under each (377 of 377, 400 of 400). The blessed function-granularity compiler emits EXACTLY one .loc per function, and that 1:1 identity is the control tooth: it held ON THE NOSE in every window where it was independently measured (78,399 rows for 78,399 functions across the two both-compiler windows). The new compiler emits 18,835,389 rows over the same population -- 10.9x denser -- with ZERO per-file regressions across all 11,121 files and no file losing its line info (nx_dwline_corpus_gate, which NAMES every regressing file individually and named none). Where the run used the derived baseline for speed it was CROSS-VALIDATED first: fast mode reproduced the both-compiler numbers EXACTLY on an identical 400-file range (31,000 functions, 165,800 rows, 400 improved, 0 regressed), and the invariant is deliberately NOT asserted in derived mode because that would be circular. The narrow proof is also kept: nx_dwline_stmt_gate 13/13 shows all four source lines of a two-function probe recovered from real addresses in the emitted ELF, with a baseline tooth asserting the OLD compiler LACKS the statement lines so the gain is attributable. Line numbers ride OUT OF BAND keyed by instruction pointer -- struct Instr was NOT widened -- and nx_cc_equiv_gate stayed 10/10 + selfhost with byte-identical ea/eb on every row, proving the change is inert when -g is off. STILL PARTIAL and graded as one: .debug_info (types and variables) and an actual stepping debugger are ABSENT, and this axis is a conjunction -- debug INFO without a debugger is not a debugger. gdb-on-C stays the bar; both are filed rungs, not design choices

Python REPL + notebooks the bar; wasm target + nishi-pages could host ours (queued)

Deliberate different-path bet: content-addressed substrate, no version negotiation, zero dependency-confusion surface -- still graded No on presence until the bet is measured as an exceed

Found and named real nx_cc bugs (empty-.s class 2026-07-05; EMI oracle born catching a silent optimizer miscompile [emi2014]; gate 10/10 GREEN 2026-07-07); peers rely on external fuzzers (rustlantis, go-fuzz, csmith). PROBING IS NOW A NATIVE FIRST-CLASS CAPABILITY, not a pile of shell scripts (2026-08-14): nx_langdiag_gate runs the whole language-diagnostic probe corpus in NishiLang -- 11 rows GREEN through the shipped gate runner -- and it closed a real hole in how this estate had been testing refusals. The prior bash cells asserted only THAT a probe was refused (the emitted assembly was empty); a refusal for a COMPLETELY DIFFERENT reason passed them silently, which is the same blind-by-construction shape as a deny-test suite that never asks which rule fired. Every row now pins the refusal to its own rule phrase or capability slug, so a wrong-reason refusal is RED -- BITE-PROVEN by planting a slug the rule never prints, which yields exit=2 want_exit=2 with the reason mismatched, exactly the case the old cell passed. Acceptance rows (must compile AND emit real assembly) are the discrimination control: without them a compiler that refused every input would score full marks on the refusal rows. It composes the estate's incumbents rather than adding a ruler -- nx_gate_lib's fork-and-assert case runner for mechanics, nx_gate_verdict for adjudication (the promote door REFUSED the first build for rolling its own verdict, and migrating was taken over the documented override) -- and it reports a third state, UNRESOLVED, when the compiler under test cannot be found, because 'I could not look' is not 'it is broken'

F1-F16 taxonomy + P1-P10 meta-patterns + 1651 external oracles classified into 26 ranked axes driving make-it-unrepresentable rungs; PLUS an AI-authoring friction lane (2026-08-13): full-population mining of the AI seats' own session transcripts (1,090 files / 2.88 GiB, counted not sampled) ranks which language defects burn agent tokens -- SEGV-class debugging 5,151 hits across 376 sessions, the paren-cast-index silent-truncation trap in 45 -- and the top-ranked reachable trap was root-caused, witness-gated and toolchain-promoted the same day; peers have public trackers, not ledgers wired to language change, and none wires AI-usage telemetry into language evolution; since 2026-08-13 night the loop is CLOSED IN THE COMPILER ITSELF AND COUNTED BY THE BUILD DOOR: capability-limit refusals stamp greppable capability=<slug> markers (float-int-boundary, call-arity-ceiling, memory-safety-enforcement) at the moment of friction, and /api/build now appends every marker to a DURABLE demand journal (knowledge/status/lang_demand.jrnl: epoch, slug, target; bounded 8/build, append-only, never fails a build -- live-bitten: one refused build wrote its 3 rows the moment it failed), so real demand re-ranks the climb with NO human in the circuit; the same session's refusal check also surfaced a 15-site latent parser gap (chained casts `X as *u8 as i64` were HALF-APPLIED forever, the dangler silently skipped) which is now a real chain, witness-gated

The chain nx_cc -> nxasm -> ELF is ours bits-up and compiles on the NAS over the mgmt API (build-over-API GREEN 2026-07-06); Rust/Zig/Swift sit on LLVM; Go owns its backend but links foreign substrate below

A 100 percent integer LLM trained + greedy-matches the float reference 4-for-4 (2026-07-09); gate-grounded across codec and compute censuses; no peer ships float-free determinism as language doctrine

Rebuild byte-identical dd1baff6 MEASURED 2026-08-04; Go reproducible-by-default (1.21+) is the bar; JVM/gradle and npm builds are not bit-exact by default

X-Nishi-Cap ocap tokens + fixed-arg pinning live-proven 2026-07-08; attenuate-only delegation audited in cap_consent.log; no peer language ships an ocap-gated ops surface

Nobody mainstream ships it (CompCert is a separate verified C compiler; RustBelt/miri are research); our eqsat engine exists but is unwired (honest) [egg2021]; queued behind the equivalence net