Nishi Family › Compare › Sovereign Toolchain & Build Performance
Nishi Compare · measured, not asserted
Sovereign Toolchain & Build Performance
Nishi vs the field — every Nishi cell is measured against real organ source at emit time; each gap names the watch contract that will close it.
Nishi nx_cc_sovereign -> nxasm_x86 (bits-up, no gcc/llvm) vs industry compile SOTA -- measured 80-90ms/gate, whole-program, no cache
Layer 1 · Executive
Where we are. Measured 2026-08-17 on the LOCAL sovereign toolchain (WSL, no NAS load): nx_cc_sovereign compiles a 275-line gate to 15,198 asm lines in 71ms, nxasm assembles it in 9ms -- 80ms end to end. UPDATED 2026-08-23: dead-code elimination LANDED 2026-08-18 (B1, opt_module_dce_mark), and on the LIVE promoted toolchain a trivial main importing nx_syscalls now emits 976 asm lines / 10 functions / a 7,126 B binary instead of the whole 4,311-line syscall closure (measured via /api/build himport, nx_cc_sovereign 0288e2ea). So the compiler is FAST and the REMAINING cost is STRUCTURAL: whole-program compilation, no separate compilation, no content-addressed build cache => an unchanged closure is still re-COMPILED on every build even though it is no longer re-EMITTED. On the NAS this is amplified by box contention, per-request /api/build orchestration, and bursting parallel builds (a 35-build burst drove load to 20 with edge 503s). The genuine EXCEEDs are deterministic content-hashed reproducible builds and never-brick-the-builder guards. Counts below are measured at emit. ADDED 2026-08-21: the roadmap layer of this domain was INVISIBLE TO THE RANKER until today -- see the grammar note above -- so nothing here had ever been prioritised against the rest of the fleet.
Where we need to go. Builds and compiles must not be a bottleneck: reach industry build-engineering SOTA (Go sub-second builds, Rust/Zig recompile-only-changed, ccache/Bazel content caches) WITHOUT surrendering the two sovereign EXCEEDs -- deterministic bit-exact reproducibility and a bits-up no-gcc/llvm stack. Every rung is gated by an equivalence proof (rebuild the estate, byte/behaviour-identical) because the compiler is load-bearing: a codegen regression miscompiles everything.
The unit. 1 u = one measured session-leg. Toolchain rungs are compiler-surgery class, so estimates carry more risk than organ rungs; each republishes actual-vs-estimate when it lands.
Cost to kill the redundancy: 2 u remaining of 4. B1 dead-code elimination LANDED 2026-08-18 (redundant EMISSION gone: a trivial main is 976 asm lines, not 4,311); B2 content-addressed cache is the remaining safest win -- it needs no separate-compilation rewrite and makes identical rebuilds free.
Cost to industry build-speed parity: 9 u. adds B3 separate compilation / precompiled closure + B4 parallel scheduler; B5 remote cache is beyond parity.
Research bar. Zig incremental compiler (2026) is measured on self-hosted, in-place incremental recompilation -- recompiles only the changed function, sub-100ms edit-build loops. Theirs: the 2026 self-hosted-compiler speed frontier. Ours: B3+B4 reach it while keeping our determinism, which Zig does not guarantee bit-exact [@zig-incremental].
Research bar. Bazel / ccache content-addressed cache is measured on build actions keyed by content hash, never re-run an identical action, shared across a fleet. Theirs: the never-rebuild-the-same-thing-twice bar. Ours: B2 is the local form (closure_sha256 already computed); B5 is the remote form [@bazel-remote-cache].
10 of 14 capabilities measured|3 of them measured exceeds|4 open|coverage 714/1000|adoption 10 full / 0 partial
Layer 2 · Roadmap
Do this next — computed by the ranker, never chosen by a seat
Order from nx_compare_rank (nx_dr_ocm: (deficit + cost-of-delay + option + enables) x sponsor x self-sufficiency x momentum / cost). FINISH rows are rungs whose symbol is present but whose organ is short of full adoption: the cheapest closures on this board, listed before any new work. Stamp: # asof=1787883532 domain=toolchain target_version=1.0 rungs=5 done=2 open=3 finish=0 ranker=nx_dr_ocm
| # | Stage | Rung | Priority | Derivation |
|---|---|---|---|---|
| #1 | 1.0 | Cost-aware parallel scheduler (B4) bld_sched_parallel | 1600 | v=12 m=2 c=15 |
| #2 | 1.0 | Separate compilation / precompiled closure (B3) cc_emit_object | 800 | v=16 m=2 c=40 |
| #3 | later | Remote / distributed build cache (B5) bld_cache_remote | 666 | v=5 m=2 c=15 |
Critical path — contract, done-rule, executor, cost
| Rung | Closes with | Definition of done (pre-declared) | Executor | Est. |
|---|---|---|---|---|
| Dead-code elimination (reachability) (B1) | opt_module_dce_mark | LANDED 2026-08-18 (actual 1 u vs estimate 2): mark-only reachability from main (opt_module_dce_mark in nx_opt.nx, consumed by the opt loop and x86ctx_emit_module_live, --no-dce as the A/B lever). RE-KEYED 2026-08-23 from cc_gc_unreached (never defined anywhere, ABSENT-PROVEN over 23,071 files) to the symbol that shipped, so the board stops ranking a landed rung first. DONE-RULE MEASURED 2026-08-23 on the live toolchain (nx_cc_sovereign 0288e2ea, /api/build himport = import nx_syscalls + a main calling sys_exit): asm 976 lines / 32,488 B / 10 functions (main, sys_exit, the 8-function default-on crash guard) / binary 7,126 B, down from the 4,311-line whole-closure emission. Original done-rule: the equivalence gate stays GREEN (every estate binary rebuilds byte- or behaviour-identical) AND a trivial main's asm drops from 4,311 lines toward its actual reachable set. A DCE that drops a reached function is a miscompile, and a missed edge is a LOUD undefined-label assemble failure, never a wrong binary. | Compiler | 2 u |
| Content-addressed build cache (B2) | bld_cache_cas | Key a cache on (src_sha256 + closure_sha256 + toolchain_sha) -> cached .sov.elf; hit = copy, miss = build + populate. DONE-RULE: an unchanged rebuild returns byte-identical bytes with ZERO compiler invocation (proven by a fork counter) and a one-byte source edit MISSES. The daily ~1000-binary drift census becomes file-copies. | Organ | 2 u |
| Separate compilation / precompiled closure (B3) after B1 | cc_emit_object | Compile the shared base closure (syscalls, sha256, bits, gate_verdict) ONCE to a cached object with a symbol table; a target build emits only its own functions and links. DONE-RULE: equiv gate GREEN AND a gate build's compile time drops from ~80ms toward the ~5ms floor, measured. The big architectural rung. | Compiler+linker | 4 u |
| Cost-aware parallel scheduler (B4) after B2 | bld_sched_parallel | Replace the BUILD-ADMIT load-serialize with a scheduler that runs the build DAG across cores up to a measured memory/CPU envelope. DONE-RULE: N independent builds complete in ~max(one) not ~sum, no OOM and no edge 503 on a declared batch. | Organ | 3 u |
| Remote / distributed build cache (B5) after B2 | bld_cache_remote | The B2 cache shared across hosts, content-addressed and integrity-checked on fetch. DONE-RULE: a second host reuses the first's cached artifact after proving its hash. Beyond parity. | Organ | 3 u |
Milestones
| Milestone | Rungs | Cumulative |
|---|---|---|
| T0 · Redundancy killed (DCE + local cache) | B1,B2 | 4 u |
| T1 · Industry build-speed parity | B3,B4 | 9 u |
| T2 · Fleet-scale caching | B5 | 12 u |
Layer 3 · Engineering
How this is scored. Every Nishi mark is measured: the generator reads the real organ source on disk and requires the implementing symbol to exist (no self-grading). A watching tag names the organ and symbol contracted to close a gap — the mark flips itself on the next compare beat when that workstream ships, and the
comparewatch- plane row flips with it. The flip is necessary, not sufficient: it proves the symbol exists, never that the capability is good. The bar is the rung's pre-declared done-rule, proven by its gate — a symbol shipped without the behaviour behind it is a defect, and the flip is exactly what makes that defect visible instead of quiet. Competitor marks record documented capability presence — presence, not depth or scale. Adoption is measured too: every measured row carries where its organ stands on the estate's ladder (source → built → promoted → registered → invoked; libraries by importer reach minus validation importers; gates by the execution surfaces that run them). A row is fully adopted only at the top of its ladder; anything short is tagged partial with the exact remedy, so a build nobody promoted can no longer read as shipped. Census stamps: importers asof 1787849099, gate census asof 1787855507 (unix seconds; -1 = census absent).Capability matrix — measured against source
◉ leads / measured exceed● present◐ partial○ absent · click any capability for its evidence
| Capability | Nishi | Clang/LLVM | Go | Rust/Cargo | Zig |
|---|---|---|---|---|---|
| LIVE | |||||
Self-hosted bits-up toolchain (no gcc/llvm/binutils)Measured exceed:sbr_is_toolchain in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. nx_cc_sovereign + nxasm_x86, sovereign to the byte; Go self-hosts, Zig self-hosting, Rust rides LLVM, Clang is a vast C++ dep Adoption: LIVE — fully adopted (top of its ladder). | ◉ | ○ | ● | ○ | ◐ |
Deterministic reproducible build (bit-exact, content-hashed)Measured exceed:sbr_mtime in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. EXCEED: integer codegen + closure_sha256 => byte-identical rebuild PROVES a refactor neutral; reproducible builds are an industry ASK, ours is by construction [reproducible-builds] Adoption: LIVE — fully adopted (top of its ladder). | ◉ | ◐ | ◐ | ◐ | ◐ |
Never-brick-the-builder / no accidental daemon deployMeasured exceed:sbr_is_daemon in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. EXCEED: the lane REFUSES to install a toolchain binary or hot-swap a daemon as a build side effect; no mainstream tool guards its own blast radius Adoption: LIVE — fully adopted (top of its ladder). | ◉ | ○ | ○ | ○ | ○ |
Dead-code elimination (emit only reachable functions)Measured:opt_module_dce_mark exists in runtime/nx_opt.nx, verified at emit. LANDED 2026-08-18 as opt_module_dce_mark (nx_opt.nx): mark-only reachability from main over OP_CALL/OP_TAIL_CALL callees + VK_FUNC_ADDR values, consumed by the opt loop and x86ctx_emit_module_live; --no-dce is the A/B lever and a missed edge is a LOUD undefined-label assemble failure, never a wrong binary. RE-KEYED 2026-08-23: the contract had watched cc_gc_unreached (ABSENT-PROVEN over 23,071 files) while the rung shipped under this name, so a LANDED rung sat OPEN on the board for five days. MEASURED 2026-08-23 on the LIVE promoted toolchain (nx_cc_sovereign 0288e2ea, /api/build himport = import nx_syscalls + main calling sys_exit): 976 asm lines / 32,488 B / 10 functions emitted (main, sys_exit, and the 8-function default-on crash guard) / binary 7,126 B -- against the pre-B1 whole-closure emission of 4,311 lines for a trivial main. --gc-sections is the industry form [ld-gc-sections] Adoption: LIB-WIRED importers=23 nonval=20 — fully adopted (top of its ladder). | ● | ◉ | ● | ● | ● |
| GAP | |||||
Separate compilation (per-module cached objects)Open — watchingruntime/nx_compile_x86.nx : cc_emit_object, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. Every build recompiles the closure from source; Clang .o, Go packages [go-build-cache], Rust codegen-units, Zig compile a module ONCE and link. Est 80ms -> ~5ms | ○ | ◉ | ◉ | ◉ | ◉ |
Incremental compilation (recompile only changed)Open — watchingruntime/nx_compile_x86.nx : cc_incremental, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. Rust [rustc-incremental] + Zig [zig-incremental] in-place incremental (2026 frontier) + Go package cache [go-build-cache] recompile only changed; ours rebuilds whole-program every time | ○ | ● | ◉ | ◉ | ◉ |
Content-addressed build cache (never rebuild identical)Measured:bld_cache_cas exists in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. closure_sha256 already computed -- key a cache on (src+closure+toolchain), hit=copy. ccache/Bazel reference [ccache-manual]. Turns the ~1000-binary daily drift census into file-copies Adoption: LIVE — fully adopted (top of its ladder). | ● | ● | ● | ● | ● |
Parallel build scheduler (beyond the load throttle)Open — watchingruntime/_hdl_build/nx_sov_build_run.nx : bld_sched_parallel, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. make -j / cargo / go schedule the DAG across cores [ninja-manual]; ours has a BUILD-ADMIT load gate that SERIALIZES under contention (what made a 35-build burst hit load 20). A cost-aware scheduler replaces the throttle | ○ | ◉ | ◉ | ◉ | ● |
Remote / distributed build cache + farmOpen — watchingruntime/_hdl_build/nx_sov_build_run.nx : bld_cache_remote, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. Bazel/Buck2 remote execution + fleet-shared cache [bazel-remote-cache] is the scale bar; ours is single-box. Far horizon | ○ | ◉ | ● | ● | ○ |
| LIVE | |||||
Whole-program compilation (cross-module inlining possible)Measured:sbr_name_is exists in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. Ours is whole-program BY DEFAULT (one .s per target) -- LTO-class cross-module visibility for free; LLVM ThinLTO [llvm-thinlto] / Rust fat-LTO are the optimizing reference Adoption: LIVE — fully adopted (top of its ladder). | ● | ◐ | ● | ◐ | ◐ |
Concurrent-safe builds (per-target flock, no mid-build clobber)Measured:sbr_mtime exists in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. Per-target _build/<name>.lock so parallel sweeps never overwrite each other mid-build; throughput is the GAP rows Adoption: LIVE — fully adopted (top of its ladder). | ● | ● | ● | ● | ● |
Build admission control (mem + load gated from /proc)Measured:sbr_is_daemon exists in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. BUILD-ADMIT reads live /proc mem+load and GRANTS or defers before compiling; thresholds are named consts, argv-overridable. make/cargo/go have no memory-aware admission Adoption: LIVE — fully adopted (top of its ladder). | ● | ● | ● | ● | ● |
Build + run in one invocation (exit == the program's exit)Measured:sbr_mtime exists in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. nx_sov_build_run compiles -> assembles -> runs and returns the program's own exit; go run / cargo run are the edit-run-loop reference Adoption: LIVE — fully adopted (top of its ladder). | ● | ● | ◉ | ● | ● |
Optimizing backend (regalloc, sibcall, LICM, SIMD/AVX2)Measured:sbr_name_is exists in runtime/_hdl_build/nx_sov_build_run.nx, verified at emit. nxasm_x86 carries real codegen (elf history: sibcall/licm/prealloc/f32x8/avx2/clmul); LLVM -O3 is the reference, ours a focused subset Adoption: LIVE — fully adopted (top of its ladder). | ● | ◉ | ● | ◉ | ● |
Risk register
| Risk | Likelihood x impact | Mitigation |
|---|---|---|
| A codegen or DCE change miscompiles the load-bearing compiler | possible x catastrophic | Every rung's done-rule is an EQUIVALENCE proof: rebuild the estate and byte/behaviour-compare before promoting; the compiler ships only through its own canaried lane, never hand-copied. |
| A cache returns a stale or wrong artifact | possible x high | Content-addressed keys (src+closure+toolchain hash); a hit is byte-verified before use; a key miss on any input change is the tooth. |
| Speed work erodes the determinism EXCEED | possible x high | Reproducibility is a shipping criterion: every rung re-proves byte-identical rebuild before it counts. |
On these two registers. Rows are declared in the domain's plan file and carry the debt id, which is the join key back to the sovereign debt plane — that plane, not this page, is the authority on state. Reconciling them automatically (the regen reading the plane and refreshing these rows) is a named, owed rung; until it lands, treat an id here as a pointer to look up, not a status to trust.
Honest verdict. Measured 2026-08-17 (local, no NAS load): a full gate build is 80-90ms -- the compiler is NOT the bottleneck. But it compiles whole-program with NO separate compilation and NO content-addressed cache, so most of every build re-emits an unchanged closure. Dead-code elimination LANDED 2026-08-18 (opt_module_dce_mark; re-keyed on this board 2026-08-23): measured on the live toolchain a trivial main now emits 976 asm lines / 10 functions instead of the whole 4,311-line syscall closure. The felt "slow and expensive" on the NAS is box contention + /api/build orchestration + bursting parallel builds, amplified by that redundancy. Genuine EXCEEDs: deterministic reproducible content-hashed builds by construction, and never-brick-the-builder guards in the lane. Industry beats us on build ENGINEERING (Go sub-second builds, Rust/Zig incremental, ccache/Bazel caches) but not determinism or sovereignty. Roadmap closes it safest-first: DCE, then a content cache (closure_sha256 already computed), then separate compilation, then a parallel scheduler.
Person · product · place — not yet measured for this domain
Every compare carries this layer. Declare
knowledge/compare/toolchain.ppp (rows surface|nishi or c1..c4|label|url|connect naming OUR live surface and each rival's front door), run nx_ppp_probe domain toolchain, and this section fills itself on the next beat: the same ruler on both sides — privacy and CX (third-party hosts, tracker classes, cookies, security headers), design and longevity (design hygiene, computed WCAG contrast, render-blocking resources, unsized media, script weight, theme and motion queries), findability (landmarks, skip link, on-site search, breadcrumb, headings, internal links).References
Beyond a link list. Every reference below resolves twice — the publisher's copy and, where banked, the estate's own non-rottable library mirror with a content pin — and carries its evidence class plus the exact claim on this page it grounds. Keyed marks like [key] in the matrix notes jump here. A dash means honestly absent, never assumed.
- [llvm-thinlto] LLVM Project. ThinLTO -- Clang documentation: scalable and incremental link-time optimization with a thin summary-based whole-program step and parallel backends. publisher · read in our library
knowledge/fetched/cmp_toolchain_llvm-thinlto.html· pinh0b5cc7794c42e7caa2d8b94a2eb88df4f7841afee307e9e20eac478dd7c88a4f· accessed 2026-08-18 · vendor-docGrounds: The Clang/LLVM column and the "LIVE: Whole-program compilation (cross-module inlining possible)" row: LLVM ThinLTO is the named optimizing reference for cross-module visibility; ours is whole-program by default (one .s per target) without the incremental part. - [go-build-cache] The Go Programming Language. Go 1.10 Release Notes, Build and Install: the go command maintains a content-keyed build cache and detects out-of-date packages from source content and build flags, never modification times. publisher · read in our library
knowledge/fetched/cmp_toolchain_go-build-cache.html· pinhebcefe0dfc2d09e662f5b37d4a308bd027c8f379659bf6ee531a71eda487e3e2· accessed 2026-08-18 · vendor-docGrounds: The Go column across the "GAP: Content-addressed build cache (never rebuild identical)", "GAP: Incremental compilation (recompile only changed)" and "GAP: Separate compilation (per-module cached objects)" rows: Go packages compile once into a content-keyed cache, the sub-second-build bar the verdict names. - [rustc-incremental] Rust Compiler Development Guide: Incremental compilation -- the query system's red-green algorithm reuses unchanged query results across compilations. publisher · read in our library
knowledge/fetched/cmp_toolchain_rustc-incremental.html· pinh4b2809b4691b1eac5f4e4b0f1512a99c267efe7d38f2058231b6bc108838c74a· accessed 2026-08-18 · vendor-docGrounds: The Rust/Cargo column on the "GAP: Incremental compilation (recompile only changed)" row (graded 2): rustc's red-green incremental scheme is the mechanism behind that code; ours rebuilds whole-program every time. - [zig-incremental] Zig Software Foundation. Zig 0.14.0 Release Notes: in-place incremental compilation (-fincremental) with file-system watching, compile-error feedback in tens of milliseconds on a large codebase; not yet on by default. publisher · read in our library
knowledge/fetched/cmp_toolchain_zig-incremental.html· pinh67cb7a516762feaa8462e0a8184cad5a3668be723534ddfa28310f8b8be1d2d6· accessed 2026-08-18 · vendor-docGrounds: The Zig column and the toolchain.plan bar "Zig incremental compiler (2026)": the self-hosted in-place incremental recompilation that bar names as the speed frontier, quoted from the vendor's own release notes rather than assumed. - [bazel-remote-cache] Bazel documentation: Remote Caching -- an action cache keyed by action hash plus a content-addressable store (CAS) of outputs, shareable across a fleet. publisher · read in our library
knowledge/fetched/cmp_toolchain_bazel-remote-cache.html· pinh78f41f753b39b22b4192cc6b7b8576e881dbe61c0986b385eb8eee6e299d0fc3· accessed 2026-08-18 · vendor-docGrounds: The toolchain.plan bar "Bazel / ccache content-addressed cache" and the "GAP: Remote / distributed build cache + farm" row: action-hash keys over a CAS is exactly the shape rung B2 (local) and B5 (remote) declare, with the byte-verified-on-hit tooth the risk row demands. - [ccache-manual] ccache(1) manual: a compiler cache that hashes the preprocessed input, compiler and options into a key and re-serves the cached object on a hit. publisher · read in our library
knowledge/fetched/cmp_toolchain_ccache-manual.html· pinh1d9849cd84ed5dfbd2f218c86c9a7fb8346fccd7147425029166b64aedfe19d0· accessed 2026-08-18 · vendor-docGrounds: The "GAP: Content-addressed build cache (never rebuild identical)" row names ccache/Bazel as the reference: this manual is the single-host form of that cache, the analogue of rung B2 keyed on (src + closure + toolchain hash). - [ld-gc-sections] GNU Binutils. ld Options: --gc-sections enables garbage collection of unused input sections at link time. publisher · read in our library
knowledge/fetched/cmp_toolchain_ld-gc-sections.html· pinh0f235ad961de9aaddadb042818b2187f3b6c17960631d0c86c4f27d18c79f136· accessed 2026-08-18 · vendor-docGrounds: The "GAP: Dead-code elimination (emit only reachable functions)" row states that --gc-sections is standard: this is the option's own documentation, the linker-level analogue of rung B1's reachability mark-sweep from main. - [reproducible-builds] Reproducible Builds project. Definitions: a build is reproducible if, given the same source, build environment and instructions, any party can recreate bit-by-bit identical artifacts, verified by cryptographic hash comparison. publisher · read in our library
knowledge/fetched/cmp_toolchain_reproducible-builds.html· pinh67c75382073160d9cb1253b6991c361eab77309b29f7d2e9f1a6bb91e253eff0· accessed 2026-08-18 · published-standardGrounds: The "LIVE: Deterministic reproducible build (bit-exact, content-hashed)" EXCEED row: this is the industry definition the row says is an ASK elsewhere and by construction here (integer codegen + closure_sha256, byte-identical rebuild proves a refactor neutral). - [ninja-manual] Ninja build system manual: builds always run in parallel, by default one job per CPU, designed for instant incremental builds on very large projects. publisher · read in our library
knowledge/fetched/cmp_toolchain_ninja-manual.html· pinhc129b074c5c574d16fd959822eb51e9adba3d5fa25249c91175b555e4f7d7b5b· accessed 2026-08-18 · vendor-docGrounds: The "GAP: Parallel build scheduler (beyond the load throttle)" row and rung B4: the field runs the build DAG across cores by default; ours serializes under a BUILD-ADMIT load gate, which is why a 35-build burst hit load 20.
generated by nx_swcompare_matrix (sovereign NishiLang organ) from knowledge/compare/toolchain.matrix · every Nishi cell verified against organ source at emit time · watch cells re-measured on every compare beat · zero JS, zero trackers