Internal Cast study · 2026-10-27 · previous C++ vs V11 C++

Reuse verification.
Finish sooner.

One completed result was being verified repeatedly. Reusing its verification reduced native wall latency by 32.24% on the fixed million-row primary workflow.

The adjusted interval was -38.45% to -25.39%. All 11 controls met the predeclared nonregression limit. The change saves checksum and reporting work; join and aggregate kernels were unchanged.

32.24%
lower paired native wall latency
million-row count + join
2,400 / 2,400
successful calls with exact outputs
zero retries or exclusions
11 / 11
controls within their adjusted
+5% upper latency limit

A million rows, counted and joined.

The primary workflow counts rows by product and joins the counts back to the original million rows. These bars show the median of 100 individual calls per version. The headline uses paired block estimates, so it is not the percentage difference between these two medians.

Lower is better. Native wall includes leader execution, result verification and leader cleanup. It excludes worker spawning, worker reap, CSV export and final CLI reporting.

Every case, including the small ones.

A negative change means V11 finished sooner. The primary had to show at least a 10% gain at its adjusted upper bound and pass the sign-swap test. Each other case had to keep its adjusted upper bound at or below +5%. Passing a control means meeting that limit; it does not mean every control became faster.

Paired native wall change and family-adjusted intervals; all 12 frozen gates passed.
WorkflowChangeAdjusted intervalGate
Count by product + join · 250k-0.82%[-3.00%, +1.42%]Pass
Count by product + join · 1MPrimary-32.24%[-38.45%, -25.39%]Pass
Filter + aggregate + join · 250k+0.24%[-0.40%, +0.88%]Pass
Filter + aggregate + join · 1M-4.65%[-8.94%, -0.16%]Pass
Small pipeline-0.06%[-0.60%, +0.48%]Pass
Duplicate join keys · 64+0.31%[-0.41%, +1.03%]Pass
Empty right input · 64-0.04%[-0.63%, +0.56%]Pass
Empty left input · 64+0.35%[-0.36%, +1.08%]Pass
Pipeline + sort · 1M-5.00%[-8.06%, -1.84%]Pass
Inferred join keys · 1M-34.23%[-39.75%, -28.20%]Pass
Count + join default control · 1M-32.55%[-38.65%, -25.85%]Pass
Sum + sort · 1M+0.01%[-0.73%, +0.76%]Pass

The full command also finished sooner.

The descriptive paired full-command estimate was 8.66% lower across the same blocks. Its individual-call median fell from 1.334 to 1.220 seconds, including spawning workers, execution, worker shutdown, CSV export and final reporting. The paired estimate is separate from the percentage difference between these medians. Whole-command CPU fell from 0.88 to 0.65 seconds.

The per-call interval from the statistics snapshot to the result journal had a median of 232.12 ms before and 116.89 ms after. Collection stayed close: 79.98 to 79.41 ms. These are descriptive checks on where time went, separate from the frozen acceptance metric.

The conditions travel with the result.

Apple M5 Max, 18 cores, macOS. Three requested loopback workers, four threads each, on one shared Mac. This was one shared host, with 1,694 calls flagged contended. In 23 calls, fewer than all three requested workers joined before completion; those calls remain included.

The fixed protocol used 12 cases, 20 paired blocks and five matched repetitions per version within each block. Case and version orders were randomized in advance. Each version’s five timings became one geometric mean per block, giving 20 paired inference units. Intervals use a paired log-latency t calculation with 19 degrees of freedom and Bonferroni alpha 0.05 / 12. The primary’s exact two-sided sign-swap p-value was 1.907349e-6 over all 2²⁰ assignments.

Every complete output matched its retained previous-version CSV SHA. Printed, native JSON and journal checksums also matched. All calls were retained; there were no retries, exclusions or early success stopping. File identity reads warmed the OS cache symmetrically, so this is not a cold-storage result.

This study compares two versions of our C++ Cast tooling. It does not measure Photon or establish a new lead over Rust, Zig, Swift, Go or the market. The existing language and library results keep their original measurements and dates. No V11 multiplier was applied to them.

Source and evidence identifiers
previous source commit
4fd0ed9cbc722e7128786111ee6aa8d9d304d7fc
candidate source commit
7d94e68c043c5111f52a624bda8e347b9a9da34b
previous cast binary sha256
03f3c9cba4e45e77ec07232b588f80e94af5581e71ee4d4c6343cb9d27063701
candidate cast binary sha256
0f3dd00e29bd3a2ee2ce80aa57256e0bfc5496c78c8670a7c3de32d535ca7198
protocol sha256
64b281e778aa02de66c3dc809ae8f5d0ffef41f19dc3c4b905032602dd2641c7
records sha256
3bb5978f50e1df48140f61e65d16dfb8ec4964c6bb5b39ddf575e9ae3ee7e65e
formal analysis sha256
444beddb442026806b4ee8c754c4d96a2b9dbb0b60529c399aa0f0da987508d8
independent statistics audit sha256
5eda1cec860cd1a9010b5408b0a54c46860719d4e824d158afbdf3149c90dd2f

Summary data and evidence hashes are public. Engine source, binaries and raw operational logs remain private; the summary contains no local paths or private code.