Development documentation · Some APIs may be unreleased Published release →

Guides

HTTP request-processing benchmarks

Preview 19 — 31 October 2026

Five-round release measurements pass on macOS ARM64 and Windows x64 using the qualified runtime payloads. The macOS host was under development load; these are bounded workload measurements, not a controlled speedup comparison. Exact reports and host conditions. The notice-only archive refresh preserves the measured executable bytes.

Current development sync/concurrent GC comparison tracks plain HTTP and HTTP JSON using the standard procedure. Those experimental AOT results are separate from the published-package series below.

Development decision: shared scheduling remains opt-in — 28 October 2026

Three untraced rounds with eight clients and 1,920 warm requests per process, following 24 first-use endpoints; both collectors use matching 1 MiB heaps:

Queue / GC Ready median (s) First-use sweep (s) Warm req/s median (range) Median trial p99 (ms)
baseline-sync 5.331 2.513 1541 (1446–1572) 44.93
shared-sync 5.428 2.517 1623 (1448–1751) 43.74
baseline-live 5.602 4.571 1141 (1087–1146) 48.45
shared-live 5.750 4.550 1055 (1048–1257) 51.16

All 23,328 requests pass. Shared queues improve the sync throughput median by 5.3% but reduce the concurrent median by 7.5%; ranges overlap and three trials do not establish a general win. Keep existing scheduling and GC defaults. The DNS/native GC correctness fixes are enabled; shared ready storage stays opt-in.

Ready includes process/metadata setup; first use includes lazy compilation and I/O. This closed-loop workload is not production capacity. Separate native stack samples highlight root/store and binding costs but leave many JIT frames unnamed. AOT, offered-load limits and full context/HTTP phase profiling remain follow-up. Decision, raw data and profiles.

Development: mixed scheduling and I/O qualification — 28 October 2026

Twenty-four endpoint methods exercise nested/shared-capture tasks, allocation, synchronous files and delayed downstream HTTP. Four clients, matched 1 MiB heaps, lazy JIT and bounded tracing; one diagnostic run per mode:

Mode Checked requests 96-request warm batch (ms) Queue peak Queue residence median / p95 (µs)
baseline-sync 120 141.7 13 289.8 / 928.1
shared-sync 120 150.2 14 399.4 / 949.2
baseline-live 120 206.5 12 265.6 / 1326.7
shared-live 120 220.9 15 556.6 / 1369.5

Queue residence includes first-use and warm requests, so lazy compilation can contribute to those intervals.

All 480 requests and shutdown checks pass after qualifying DNS/multi-address and file native boundaries for concurrent GC. These are traced observations, not median throughput or production-capacity results. Shared queues do not improve this cohort. Synchronous file work still blocks the owner; DNS completion still uses polling. Untraced pressure, HTTP/binding phase profiles and AOT remain next. Evidence and limitations.

Development: immutable interface views - 28 October 2026

The runtime reuses successfully computed interface inheritance within bounded, immutable metadata scopes. Baseline includes the preceding per-pass boxing scan. Three alternating pairs per mode use identical Preview 18 libraries and current HTTP guest/native hosts on Apple M1/macOS 27.0.1, production-default codegen, 4,096 JSON requests after 16 warmups, four clients and pipeline depth 16. Medians:

Mode / GC READY before / after (s) Selection + verification before / after (s) Warm req/s before / after
Eager / sync 10.942 / 10.689 6.614 / 6.156 1,922 / 1,667
Lazy / sync 8.010 / 7.547 6.774 / 6.310 2,142 / 2,134
Eager / concurrent 13.429 / 13.131 6.639 / 6.239 1,747 / 1,779
Lazy / concurrent 7.875 / 7.831 6.504 / 6.285 1,510 / 1,465

Eight of twelve readiness pairs improve; gains are modest and variable. The short eager/sync throughput regression receives a separate longer check: three pairs of 65,536 requests give 1,891 / 1,886 req/s, with paired differences from -0.25% to +1.68%. The larger short-run gap is not reproduced; no warm-throughput or special concurrent-GC gain is claimed. Post-invocation live allocations match, while allocator reservation remains mixed.

Lazy runs still compile 870 methods and leave 811 uncompiled. First-call compilation still blocks the managed caller. These shared-host measurements do not establish production capacity or exact throughput equivalence. Full ranges, profiles, validation and tradeoffs. The preceding selection-scan cohort and specialization-source cohort retain their independent results. The latter used different libraries.

Earlier development cohort: lazy JIT — 26 October 2026

Before the metadata-selection follow-up, three-round medians on Apple M1/macOS 27.0.1 use production-default backend optimization, 4,096 measured requests per process, four clients and pipeline depth 16 after 16 warmup responses. Eager uses system code placement; lazy uses its new bounded macOS ARM64 arena. These are development fixtures, separate from Preview 18.

Handler / GC Eager ready s Lazy ready s Eager req/s Lazy req/s Lazy first response s
Plain / sync 13.436 11.129 3,315.3 3,670.5 1.213
Plain / concurrent 15.585 10.206 2,842.3 2,292.0 2.111
JSON / sync 12.800 9.954 1,936.2 2,123.1 1.697
JSON / concurrent 15.517 10.321 1,712.8 1,477.3 3.083

Earlier readiness defers work into the first request. Matched lazy placement controls improve throughput by 22–30% in paired medians, but collector tradeoffs depend on load. Complex handlers, I/O, multiple apps and cold-traffic tables and charts show where concurrent GC helps, its CPU cost, and where sync remains favorable. The full evidence retains all ranges and target failures. Older speed-override measurements are not pooled with this series.

Preview 18 — 26 October 2026

Both packages pass all five measurement stages: 55 CPU/JSON processes and 1,152 HTTP responses per platform. SDK/editor 0.1.18-neoclr.20261025.1, Raven ed1d08def, synchronous GC. Five measured rounds retain ranges; startup is separate. Native CPU uses longer batches, and HTTP uses sequential loopback requests with connection close. These results do not measure peak concurrency, allocation rates or collector comparisons.

macOS ARM64

Apple M1/macOS 27.0.1; the final archive includes PostgreSQL. Git stayed clean and no unrelated builds overlapped timing. Ordinary desktop activity remained present.

Workload Mode Median requests/s Range Median startup s
http-plain interpreter 3.53 3.43–3.67 3.314
http-plain jit 185.20 164.70–188.13 6.950
http-plain aot 192.97 178.38–193.74 0.005
http-json interpreter 2.00 1.92–2.06 3.179
http-json jit 103.27 90.92–106.06 13.283
http-json aot 107.20 77.14–108.29 0.016

Final macOS reports. The earlier base-only candidate is retained separately.

Windows x64

Windows Server 2025 on AMD Family 25 Model 1. The prior series used Model 17; CPU-control and HTTP results are lower in this hosted run. The host difference prevents attributing the change solely to the runtime and does not rule out a runtime regression. Only generated Python caches changed during measurement.

Workload Mode Median requests/s Range Median startup s
http-plain interpreter 2.71 2.65–2.76 5.408
http-plain jit 42.10 37.55–42.15 11.416
http-plain aot 37.59 36.93–39.86 0.009
http-json interpreter 1.59 1.59–1.62 5.422
http-json jit 27.30 26.55–28.14 18.664
http-json aot 27.55 24.46–30.76 0.009

Windows reports and conditions. No controlled before/after or cross-platform speedup is claimed.

Preview 17 — 22–23 October 2026

The matching macOS ARM64 and Windows x64 packages each pass all five stages: 55 CPU/JSON processes and 1,152 HTTP responses. SDK/editor version 0.1.17-neoclr.20261022.1, Raven 301e668a5. Five measured rounds retain their ranges; startup is separate. HTTP uses sequential loopback requests with connection close. Native CPU rows use longer batches than interpreter/JSON rows. Desktop and hosted-runner conditions prevent controlled speedup or cross-platform claims.

macOS ARM64

Workload Mode Median requests/s Range Median startup s
http-plain interpreter 3.70 3.53–3.78 4.282
http-plain jit 180.88 176.26–189.44 6.725
http-plain aot 188.84 134.97–199.28 0.005
http-json interpreter 1.71 1.69–1.82 4.537
http-json jit 96.31 95.80–100.79 11.456
http-json aot 99.59 99.56–100.45 0.014

Raw macOS reports and conditions.

Windows x64

Workload Mode Median requests/s Range Median startup s
http-plain interpreter 3.27 3.23–3.29 5.778
http-plain jit 62.51 52.97–65.90 9.468
http-plain aot 59.81 52.88–66.52 0.008
http-json interpreter 1.60 1.51–1.66 5.901
http-json jit 42.73 39.52–46.61 15.525
http-json aot 40.04 37.55–41.05 0.008

Raw Windows reports and conditions. Both runs record only generated Python caches in their initial Git status; no tracked input changes occurred. Earlier series below retain their original provenance and limitations. These results do not measure collector comparisons, peak concurrent throughput or HTTPS performance.

Earlier measurements

Plain-text and typed-JSON Raven servers exercise the request path in interpreter, JIT and AOT. These 18 October 2026, Apple M1/macOS 27.0 measurements use the Preview 16 package with Raven c0854cdda. All 1,152 responses across 36 processes pass validation, with zero errors. Windows results follow below as a separate hosted-runner series.

Complete SDK development refresh — 22 October 2026

The complete macOS ARM64 development SDK passes the entire sequential benchmark runner: 55 CPU/JSON processes and 1,152 HTTP responses, with unchanged-input checks. Apple M1/macOS 27.0; Raven compiler 301e668a5. This is a development candidate, not a published release or a controlled comparison with the earlier snapshot.

Workload Mode Median requests/s Range Median startup s
http-plain interpreter 3.76 3.58–3.78 4.244
http-plain jit 189.95 189.69–190.90 6.685
http-plain aot 199.38 199.20–199.67 0.006
http-json interpreter 1.73 1.69–1.77 4.492
http-json jit 96.82 92.56–101.17 11.658
http-json aot 100.61 99.65–100.71 0.013

Five measured rounds rotate modes. CPU/JSON uses 16 operations and two warmups; native CPU rows use a separate 10,000-operation, 20-warmup run. Each HTTP process validates 32 responses, discarding the first eight from timing; each mode also has one whole-process warmup. Requests are sequential loopback HTTP/1.1 with connection close, using a Python client on the same machine. Startup is separate and includes JIT compilation. No unrelated local builds or full suites overlapped timed workers; desktop and OS activity remained present. These results do not establish controlled speedups, peak concurrency, allocation rates, GC comparisons or HTTPS throughput.

Candidate identity and raw reports. The earlier development measurements are preserved. Windows qualification and the matching performance run have passed; results follow below.

Windows development refresh — 22 October 2026

Windows x64 hosted runner, Windows Server build 26100, AMD64 Family 25 Model 1. All five aggregate stages pass: 55 CPU/JSON processes and 1,152 HTTP responses. This series uses the package qualified by run 39841298887 (original package run 39835531991), with benchmark source 69441f2fd. It is separate from macOS and published Preview 16 measurements; host differences prevent platform rankings.

Workload Mode Median requests/s Range Median startup s
http-plain interpreter 2.45 1.85–2.53 7.299
http-plain jit 42.76 40.95–57.37 12.268
http-plain aot 40.04 37.79–58.89 0.010
http-json interpreter 1.27 1.25–1.29 7.143
http-json jit 28.87 26.17–29.75 19.274
http-json aot 28.18 26.19–28.43 0.009

Five rounds rotate modes. CPU/JSON uses 16 operations and two warmups; native CPU uses a separate 10,000-operation, 20-warmup series. HTTP validates 32 responses per process, discards the first eight from timing and uses one whole-process warmup per mode. Requests are sequential loopback HTTP/1.1 with connection close. Startup is separate from throughput and includes JIT compilation. These results do not measure peak concurrency, allocation/GC rates, HTTPS throughput or production load.

The aggregate reports a dirty checkout. This is retained, not relabeled clean: an audit of recorded source hashes matches 85 tracked inputs at the recorded revision (exact bytes or Windows CRLF checkout). Two generated native archives are hashed separately and have no tracked-source equivalent. The raw report does not retain the dirty path list, so its cause is not established. Every measurement's input-integrity and correctness checks pass; no controlled speedup is claimed.

Candidate identity, source audit and raw reports.

Published Preview 16 series

Workloads and results

Plain text returns ten UTF-8 bytes, Café 🌍. Typed JSON creates a Person and serializes id: 42, name: "Café team" and active: true for every request, including object construction and reflection. Every response checks framing, status and content before it contributes to the result.

Workload Mode Median requests/s Range Median startup s
http-plain interpreter 2.16 2.11–2.19 2.901
http-plain jit 142.79 137.54–150.22 5.364
http-plain aot 147.21 143.48–155.82 0.006
http-json interpreter 1.17 1.16–1.18 2.782
http-json jit 79.87 79.55–81.48 8.432
http-json aot 83.18 78.17–83.39 0.005

Windows x64

The same package passes on Windows Server 2025 (AMD Family 26 Model 2), with 55 CPU/JSON processes and 1,152 HTTP responses validated across the full run. Shared hosted-runner load is uncontrolled; these numbers are a separate series, not a comparison with the macOS machine.

Workload Mode Median requests/s Range Median startup s
http-plain interpreter 2.08 1.90–2.21 3.389
http-plain jit 62.35 45.59–69.80 6.353
http-plain aot 57.90 51.11–64.95 0.007
http-json interpreter 1.21 1.16–1.24 3.434
http-json jit 44.89 42.93–54.00 8.808
http-json aot 45.67 36.61–50.93 0.007

Windows raw reports and package identity

Measurement boundaries

Each mode has one whole-process warmup and five measured fresh processes, with rotating mode order. Each process validates 32 responses; the first eight are excluded from timing. Startup measures process launch to listening-port readiness, including metadata loading and JIT preparation. Builds complete before measurement.

The Python client shares the machine with the server. Requests are sequential, use HTTP/1.1 loopback and close each connection. Host indexing was active. These short, fixed-count workstation runs do not measure concurrent server capacity or establish a controlled regression threshold. Request latency samples, host-load observations and artifact/input hashes are retained in the raw reports.

The optional PostgreSQL workload has not been rerun for this release. Its historical measurements do not qualify the current package. HTTPS, keep-alive, RSS and managed allocation rate are outside these measurements.

Raw plain/JSON samples and package identity · Reproduction instructions · Garbage-collection measurements

General execution · All benchmark reports

Development load investigation

After Preview 16, the offered-load investigation separates offered arrivals, successful completions, client admission misses and errors, with latency and CPU/RSS samples. It also compares worker-count and GC-policy costs. These local development experiments do not replace the release measurements above or establish production capacity; paced collection remains experimental.

The callback-path follow-up compares ServeOne handlers that await queued work, measuring deferred queued-accept storage separately from the earlier explicit-accept fixture. Public API semantics and collection defaults are unchanged.

Development Serve(handler) now owns bounded concurrent dispatch and handler completion. Its matched load comparison uses the same asynchronous handler and shutdown control as application-managed ServeOne loops, retaining overload misses and latency alongside throughput.

Development Serve sustained-load follow-up

After reducing concurrent desktop activity, the connection-close Serve fixture passes two 120-second trials at 400 offered requests/sec with experimental paced GC: all 96,000 responses validate, with p99 latency 115.8/98.6 ms. A 500/sec check saturates one CPU core and loses 2,606 of 15,000 arrivals at the client admission limit. These are local tested points, not default-GC or production capacity claims. Profiles, noisy counterexamples and full measurement contract.

A matched Go net/http comparison now alternates 400/500 offered requests/sec under a single Go execution processor and the same response, connection and client budgets. At 400/sec, neoCLR paced GC uses 8.6–8.9× the sampled server CPU per completion; Go passes 500/sec while neoCLR records admission misses. Go also passes two separate 30-second 2,000/sec checks. A separate 1,000/sec Go repeat fails the generator-lag criterion despite valid responses. These are explicit local configurations and tested lower bounds, not framework maximum-throughput rankings; the full reports retain latency, misses and limitations.

Development GC baseline repeat

After the ancestry fixes, a separate repeat holds the qualified Serve application object fixed and relinks current native GC adapters. It does not measure the new compiler/library cohort. Two 30-second 300/sec trials validate every response with 7.8–8.1 ms offered p99 latency. Both 400/sec trials fail qualification: 13 and 1,536 arrivals are missed; the second also has 325 ms generator-lag p99. Go passes both rates in both rounds. At 300/sec, neoCLR uses 2.33–2.46 ms sampled CPU per completion, versus Go's 0.27–0.30 ms under the explicit single-processor configuration.

These are short same-host checks with experimental paced GC, not a new speedup or production capacity claim. The earlier 400/sec qualification is historical, not a guarantee. Separate sampling still identifies allocation, collection and root publication as the leading areas to investigate. Full contract, losses, build hashes and profile.

Development: collection seed-walk optimization

A follow-up gathers a bounded set of intern roots during GC header validation, avoiding a second full-heap walk when marks are clean and the set fits. At 400 requests/sec the final candidate uses 2.212/2.207 ms CPU per timed completion, versus 2.305/2.506 ms for baseline. The first pair is about 4% lower; deterioration in the second baseline prevents attributing its larger difference wholly to the patch. The candidate still misses arrivals in two of four trials, and a Go control fails the generator-lag target. No higher reliable sustained rate is established.

The same guest object and experimental paced-GC policy are fixed. Separate collector benchmarks show gains and an overflow-path regression; all results, including rejected experiments, remain in the evidence.

Development: Task completion allocations

Promise settlement now skips replacing an empty continuation list. A separate Serve diagnostic records 0.78% fewer allocations and 0.47% fewer allocated payload bytes; Task identity and callback timing are unchanged. Interpreter/JIT/AOT contract checks pass.

Two reversed-order 60-second comparisons at 300/400 offered requests/sec show no repeatable CPU gain: a small first-pair reduction reverses in the second pair. All four candidate points miss arrivals, and one suffers 388 ms generator-lag p99. Go validates every arrival but fails one of four generator-lag targets. No higher reliable sustained rate or lower process RSS is established. Both neoCLR arms use the same current compiler/native runtime and separately built library cohorts; this is not the older fixed-guest comparison. Full results, allocation counts and failures.

Development: lazy Task callback storage

Lazy Promise callback lists and indexed dispatch reduce diagnostic allocations by 13.37% and root publications by 4.94%, preserving three-mode callback contracts. An unchanged repeat at 400 offered requests/sec passes both candidate trials, using 5.6–7.2% less sampled CPU per completion than baseline. Candidate CPU remains about 7.8–8.0 times the matched single-processor Go control.

The initial comparison includes losses in both candidate trials and severe generator lag in one. Both comparisons are retained: the cleaner repeat does not establish consistently lossless 400/sec or a higher sustained rate. These are same-host, 60-second trials with experimental paced GC. All trials, settings and allocation evidence.

Development: reusable TaskQueue storage

TaskQueue now reuses ArrayQueue storage. Focused interpreter/JIT/AOT tests cover FIFO posting, growth and wraparound. A separate diagnostic records 11.71% fewer allocations, but 1.29% more root publications and about 3.2 KB more peak live payload.

Both 60-second candidate trials validate every arrival at 400 offered requests/sec. Sampled CPU per completion falls 1.5–3.0% against the lazy-callback baseline; p99 latency rises, so no latency gain is claimed. The same-host, experimental paced-GC configuration remains far behind Go in CPU cost. Higher rates were not tested. Tradeoffs, all trials and raw evidence.

Development: bounded receive-buffer reuse

Buffered HTTP requests now reuse at most one 256-byte and one 4 KiB receive array per server. Return happens after read completion; streaming-owned buffers remain separate, and shutdown releases cached references. Inactive exchanges no longer allocate empty arrays. This is an internal cache, not a public pooling or Span API.

Separate diagnostics record 0.70% fewer allocations and 3.43% fewer allocated payload bytes, but more collections. Both 60-second candidate trials validate all arrivals at 400 offered requests/sec. The cleaner pair differs by only 0.3% sampled CPU/completion; the first baseline has severe generator lag and 717 missed arrivals. No convincing CPU speedup or higher sustained capacity is established. Candidate CPU remains roughly 7.2–7.6 times the corresponding Go control.

Ownership regressions pass interpreter/JIT/AOT. The streaming correctness fixture uses a longer test budget after the original interpreter run fails on both baseline and candidate; production timeout defaults remain unchanged. All results, ownership rules and validation limits.

Development: encoding provider reuse

Encodings.Utf8/Ascii now reuse stateless providers within runtime-owned invocation storage. Encoder and decoder sessions remain independent, with strict errors and BOM handling preserved in interpreter/JIT/AOT tests. Separate diagnostics record 3.07% fewer allocations, 3.78% fewer collections and 0.55% fewer root publications; peak live payload rises by 48 bytes.

All six matched 60-second Serve/Go trials pass at 400 offered requests/sec. Candidate CPU per completion is 1.1–1.2% lower than baseline in both orders—a small measured improvement, without establishing a higher sustained rate. Latency is mixed. The candidate still uses about 9.7–9.9 times the corresponding single-processor Go control's CPU. These remain same-host checks with experimental paced GC. Tests, limitations, failed experiment and all measurements.

Development: request-header reservation

The request decoder now reserves up to 128 header bytes initially, capped by the configured limit, to avoid repeated small-array growth. Larger headers still grow normally. Exact-limit and overflow tests pass in interpreter, JIT and AOT. This trades a small initial reservation for fewer allocations; it adds no pooling API.

Diagnostics show 1.76% fewer allocations and 0.43% fewer root publications, but 3.57% more collections. All six alternating 60-second Serve/Go trials pass at 400 requests/sec. Candidate CPU/completion is 0.9–1.0% lower in both orders, with lower p99 latency. Two short pairs and variable baseline latency do not establish a general latency improvement or higher sustained capacity.

The candidate uses roughly 7.4–7.7 times the matching Go controls' CPU. This ratio must not be compared directly with earlier sessions: Go CPU also varies between runs. The small within-session neoCLR improvement is the relevant comparison. Boundary tests and complete measurement evidence.

Development: caller profiling and first-callback reservation

A fresh CPU sample still places allocation, root publication and collection at the top. Caller attribution identifies Promise callback lists that allocate empty storage immediately before their first addition. Reserving one slot removes that allocation: 4.36% fewer allocations, 3.47% fewer payload bytes and 1.13% fewer root publications in the fixed diagnostic workload. Collections increase 2.26%. Interpreter/JIT/AOT tests preserve deferred completion/cancellation and exercise multiple callbacks; multiple registrations may incur extra growth from capacity one.

The load results do not establish a repeatable CPU speedup or a newly qualified 300/400 requests/sec rate. Initial 400/sec trials and a 300/sec fallback retain all missed arrivals and generator-lag failures. After the author reports stopping competing activities, a separate 400/sec repeat still loses arrivals in both neoCLR builds; both Go controls pass. Candidate CPU/completion is higher in one pair and lower in the other. Earlier successful trials remain historical results, not a qualification of this candidate.

The next investigations are scheduler/GC correlation around admission stalls, better load-generator isolation, and Promise result storage, which accounts for about 1.12 MB of 3.33 MB allocated in the preceding caller diagnostic. That last figure identifies where bytes are allocated; it is not a promised saving from moving the payload elsewhere. CPU/caller evidence · All comparisons, condition changes and limitations.

Development: completed async context reuse

The macOS ARM64 native runtime now reuses successfully completed async contexts by default, avoiding repeated context preparation while preserving root cleanup and fresh callback state. Native lifecycle, compiled async consumer and forced-GC HTTP checks cover the change. A compile-time fallback retains the previous path; Windows and published packages are unchanged. This does not establish shared-heap async support or Kestrel parity. See the implementation, measurements and qualification.

Development: owned-heap allocation indexing

The native runtime now searches an address-ordered free-block list for explicitly owned heaps, preserving allocation placement and object headers. Eight paired plaintext trials show 21.7%/18.7% higher mean throughput at one/four owners and 17.9%/16.1% lower CPU per response. Diagnostic search falls from about 195 to 7.6 block visits per allocation. GC, corruption, threaded-owner and forced-GC HTTP checks pass. These are short desktop comparisons with drift and variable tails, not a fresh peer comparison or Kestrel parity. See implementation, measurements and limits.

Development: transient-root handoff reuse

Native lowering now avoids empty and duplicate temporary-root publications while retaining every collection and worker boundary. Forced-GC, shared-worker and async consumer checks pass. Eight paired plaintext trials show 10.8%/8.6% higher mean one/four-owner throughput and 10.2%/8.8% lower CPU per response; tails remain mixed. These short desktop trials do not establish Kestrel parity. A separate work-count comparison covers ordinary task/collection samples and plain/JSON HTTP, with units and coverage gaps kept explicit. See implementation and evidence and workload comparison.

Development: compiler-owned transient descriptors

The native backend now validates generated temporary-root descriptors once per publication lifetime while continuing to trace changing values. Mutable native callers retain checks. Nineteen focused tests, forced-GC HTTP, shared-worker and async consumers pass. Eight paired local plaintext trials show 4.1%/9.9% higher mean one/four-worker throughput and 3.7%/7.8% lower CPU per response. Background host activity and variable tails limit these measurements; no Kestrel parity or JSON capacity claim follows. See implementation, validation and measurements.

Development: GC thread-local state

Co-locating private GC counters, pacing budgets and cleanup state reduces repeated thread-local lookups while preserving collection policy and validation. Focused pacing/thread/profile checks, forced-GC HTTP and shared-worker stress pass. Eight paired local plaintext trials show 3.4%/4.3% higher mean one/four-worker throughput and 3.7%/4.0% lower CPU per response. One-worker latency tails remain mixed; these are incremental desktop results, not a new comparison against other servers. See profile, implementation and evidence.

Development: reuse of publication admission

Root publication reuses its current-head check when entering paced GC, preserving checked native callers, instrumented hooks and collection/worker behavior. Focused stale-boundary, cleanup and thread checks plus forced/paced HTTP and shared-worker stress pass. Eight paired local plaintext trials show 3.4%/1.6% higher mean one/four-worker throughput and 3.3%/2.3% lower CPU per response. Latency tails do not uniformly improve; these are incremental desktop measurements. See contract, validation and evidence.

Development: typed boundary metadata

Native boundary execution uses small versioned headers, removing repeated JSON plan scans while preserving tracing, synchronization and rich inspection. Thirty focused tests, header rejection/live-root checks, shared workers, HTTP and async consumers pass. The plain-text object is 2.3% smaller. Eight paired local trials show 4.0%/3.9% higher mean one/four-worker throughput and 4.2%/3.9% lower CPU per response; one-worker latency tails remain mixed. New native objects require the matching runtime. These are incremental desktop results, not Kestrel parity. See contract, validation and measurements.

Development: binary slot metadata

Storage and transient execution plans now also use binary count headers; rich inspection and changing-root tracing remain. Paired local plaintext trials improve AOT one/four-owner throughput 6.1%/4.0%, with 5.6%/4.3% lower CPU per response; matched owned JIT improves 3.4%/2.9%. Objects shrink about 1.3%. These are incremental development measurements, not peer parity. The validation record includes a scheduling-sensitive worker concurrency assertion failure and successful replays. See contract, evidence and limitations.

Development: publication state access

Root and GC pacing state now share a private thread-local record, avoiding a redundant state lookup during normal publication. Local paired AOT one/four-owner throughput improves 3.6%/2.0%, with 3.9%/1.8% lower CPU per response; owned JIT improves 2.2%/2.5%. Latency tails remain mixed. Collection, frame entry and other state access remain material costs. These modest desktop gains do not establish peer parity. See validation, profiles and measurement limits.

Development: collection frequency

A larger native publication budget reduces repeated collection during request handling. Local paired plaintext AOT throughput improves 15.9% with one owner and 12.1% with four; owned JIT improves 9.4%, with lower CPU per response. Diagnostic plain/JSON arena extent increases about 8/13 KB, and no-allocation cleanup may take four times as many publications. Allocation pressure and idle collection remain. These are incremental desktop results; JSON throughput and peer parity are unproven. See measurements and policy tradeoffs.

Development: exact object lookup

After the pacing change, a larger owner-local exact-address cache reduces repeated heap validation walks. Local paired plaintext throughput improves about 3% in AOT and owned JIT, with similar CPU savings, at 1.5 KiB extra native storage per thread. Latency ranges overlap. Frame and thread-local bookkeeping remain larger targets; these incremental results do not establish peer parity. See lookup evidence and tradeoffs.

Development: generated execution-state reuse

Native JIT/AOT generated hooks can reuse an owner-thread state handle across frame publication and leave. Local plaintext CPU per response improves 1.1–1.6%; throughput changes are smaller and latency tails are mixed. The cost is eight stack bytes per affected activation and about 1.8–1.9% larger native objects. New native objects need matching hosts. This does not make GC concurrent or establish framework parity. See qualification and measurements.

Development: lazy JIT and collector tradeoffs

Lazy JIT defers method lowering and native compilation until first use. The current resolver still blocks managed execution during that first call. Development measurements compare synchronous and concurrent GC across plaintext, JSON, retained objects, overlapping I/O and complex handlers under offered load. Results separate startup, first-request latency, warm throughput, CPU and memory; a throughput gain does not imply better tail latency or lower resource use.

The initial profiling cohorts use an explicit Cranelift speed override, while production codegen defaults are measured separately. Multiple-app cases use isolated processes sharing one desktop host, not hard resource quotas or a production capacity claim. See the application-load report and charts.