@greenpandastudios/aug-cli 0.19.0 → 0.21.0

package/docs/performance.md

@@ -1,12 +1,18 @@
 # Performance and benchmarks
 
-Use this page to measure an August application, read the comparison graphs, and inspect the exact August programs behind each result. The recorded results used August 0.18.0, which compiles to native code through C. The current compiler is 0.19.0; rerun the suite before comparing a new release. Always measure work that resembles your application.
+This page publishes measurements for specific August programs alongside C, Node, and Python versions. Read the graphs for a quick comparison, inspect each program below, and use the reproduction commands to measure work that resembles your application.
+
+The recorded suite uses the August 0.21.0 candidate and LLVM 23.1.2 native output. A result for one workload and host does not establish a general speed advantage or production readiness. [Readiness](production-readiness.md) covers reliability and deployment evidence separately.
+
+The [extended qualification](qualification-results.md) adds eight C comparisons for numeric, collection and application work. The [safety gyms](safety-gyms.md) exercise results, rejected operations, cleanup and memory checks separately. Each measured program has a downloadable project and a code/spec view in the [gallery](examples/index.md#measured-programs).
+
+The [DGX Spark results](dgx-spark.md) record a second physical ARM64 host, including all benchmark programs, safety gyms and real public native imports. Read each host's measurements separately.
 
 ## Read the graphs
 
 Execution and memory bars use **lower is better**. HTTP throughput uses **higher is better**. Read the workload name and units before comparing: a 20,000-entry map and a two-million-step CPU loop do different amounts of work. The execution panels have separate linear scales; compare implementations within a panel. Tables provide exact values and remain readable on a phone.
 
-All results below were recorded on September 29, 2026: Apple M5, macOS Darwin 25.6.0, ARM64, Apple Clang 21, Node 24.18.0, CPython 3.12.14. August and C use `-O2` without LTO. [Raw samples, checksums, build timings and environment](benchmark-results.json) are committed with this page.
+All results below were recorded on October 2, 2026 (UTC): Apple M5, macOS Darwin 25.6.0, ARM64, LLVM 23.1.2 for August, Apple Clang 21 for the C reference, Node 24.18.0, and CPython 3.12.14. August and C use `-O2` without LTO. [Raw samples, checksums, build timings and environment](benchmark-results.json) include the LLVM tool and runtime identities.
 
 ## Execution time
 
@@ -16,15 +22,15 @@ All results below were recorded on September 29, 2026: Apple M5, macOS Darwin 25
 
 | Workload | August | C | Node | Python |
 | --- | ---: | ---: | ---: | ---: |
-| Startup | 1.46 ms | 1.29 ms | 19.07 ms | 8.42 ms |
-| CPU · 2 million iterations | 7.24 ms | 8.17 ms | 30.22 ms | 194.98 ms |
-| Map + Set · 20,000 entries | 2.54 ms | 1.65 ms | 22.31 ms | 10.36 ms |
-| Map + Set · 200,000 entries | 15.10 ms | 6.38 ms | 38.33 ms | 26.44 ms |
-| JSON · 5,000 round trips | 6.92 ms | 2.01 ms | 20.84 ms | 19.20 ms |
+| Startup | 1.43 ms | 1.19 ms | 19.31 ms | 16.18 ms |
+| CPU · 2 million iterations | 7.74 ms | 8.38 ms | 30.64 ms | 252.62 ms |
+| Map + Set · 20,000 entries | 2.71 ms | 1.64 ms | 22.58 ms | 18.81 ms |
+| Map + Set · 200,000 entries | 16.81 ms | 6.31 ms | 37.96 ms | 40.36 ms |
+| JSON · 5,000 round trips | 7.23 ms | 1.94 ms | 21.16 ms | 31.84 ms |
 
 [benchmark-execution-end]: #
 
-Times include a fresh process's startup and exclude compilation: 3 warmups and 15 measured runs for each implementation, with the execution order rotated. Every run must produce the expected checksum. Node and Python start a new interpreter each time; these are batch timings, not warmed server-loop or steady-state JIT timings. The startup row helps make that cost visible; subtracting medians would not establish a new measured result.
+Times include a fresh process's startup and exclude compilation: 3 warmups and 60 measured runs for each implementation, with the execution order rotated. The measurement client runs outside the compiler process, and every executable must produce the expected checksum. Node and Python start a new interpreter each time; these are batch timings, not warmed server-loop or steady-state JIT timings. The startup row helps make that cost visible; subtracting medians would not establish a new measured result.
 
 The programs below are the actual benchmark sources. The suite checks their printed results against the C, Node and Python references on every run.
 
@@ -32,7 +38,7 @@ The C reference is tailored to these inputs: it preallocates integer tables and
 
 [benchmark-summary-start]: #
 
-The CPU program takes **7.24 ms** in August and **8.17 ms** in C on this host. The large-collection program takes **15.10 ms** in August. These are measurements of the shown programs, not guarantees for other applications. JSON batch time includes interpreter startup for Node and Python; it does not establish a universal JSON-throughput advantage.
+The CPU program takes **7.74 ms** in August and **8.38 ms** in C on this host. The large-collection program takes **16.81 ms** in August. These are measurements of the shown programs, not guarantees for other applications. JSON batch time includes interpreter startup for Node and Python; it does not establish a universal JSON-throughput advantage.
 
 [benchmark-summary-end]: #
 
@@ -45,6 +51,7 @@ Save this as `main.aug`. Its result is `7`; the measurement includes starting an
 **main.aug**
 
 ```aug project=benchmark-startup file=main.aug
+// aug-spec: "main.aug.md" explains this file. Read it before changes; refresh with aug spec.
 print(value=7)
 ```
 
@@ -60,6 +67,7 @@ This loop performs two million dependent integer steps. Its result must be `8196
 **main.aug**
 
 ```aug project=benchmark-cpu file=main.aug
+// aug-spec: "main.aug.md" explains this file. Read it before changes; refresh with aug spec.
 // A loop-carried dependency prevents removal of the computation.
 int state = 123
 int index = 0
@@ -82,6 +90,7 @@ This creates a Map and Set, inserts 20,000 values, checks membership, and sums v
 **main.aug**
 
 ```aug project=benchmark-collections file=main.aug
+// aug-spec: "main.aug.md" explains this file. Read it before changes; refresh with aug spec.
 own Map<int, int> values = {}
 own Set<int> unique = {}
 int index = 0
@@ -109,13 +118,15 @@ These two files belong in one folder. The program parses JSON, reads a typed rec
 **data.aug**
 
 ```aug project=benchmark-json file=data.aug
+// aug-spec: "data.aug.md" explains this file. Read it before changes; refresh with aug spec.
 record Payload(int id, string message, List<int> values)
 ```
 
 **main.aug**
 
 ```aug project=benchmark-json file=main.aug
-import parse from august.json
+// aug-spec: "main.aug.md" explains this file. Read it before changes; refresh with aug spec.
+import parse from json
 import Payload from data
 int checksum = 0
 int index = 0
@@ -131,6 +142,15 @@ catch JsonError error:
     exit(status=1)
 ```
 
+**main.yaml**
+
+```yaml project=benchmark-json file=main.yaml
+
+
+packages:
+  json: "https://github.com/GreenPandaStudios/augscript/src/stdlib/json#v0.19.0"
+```
+
 
 [benchmark-source-json-end]: #
 
@@ -142,13 +162,13 @@ catch JsonError error:
 
 | Clients | August req/sec | Node req/sec | August p95 latency | Node p95 latency |
 | ---: | ---: | ---: | ---: | ---: |
-| 1 | 23,526 | 25,580 | 0.05 ms | 0.04 ms |
-| 16 | 73,370 | 69,166 | 0.37 ms | 0.40 ms |
-| 64 | 65,365 | 69,260 | 1.74 ms | 1.32 ms |
+| 1 | 21,046 | 23,679 | 0.06 ms | 0.05 ms |
+| 16 | 58,708 | 55,557 | 0.46 ms | 0.49 ms |
+| 64 | 54,436 | 51,730 | 2.08 ms | 1.94 ms |
 
 [benchmark-http-end]: #
 
-A real August `GET /bench` endpoint returns a newly constructed typed JSON record. The Node reference constructs and serializes the same response. Both run on loopback with HTTP/1.1 keep-alive, 1,000 warmup requests and three fresh-server rounds of 5,000 measured requests per concurrency level. Every response must have status 200, JSON content type, and the exact expected data. The measured runs had zero errors. p95 is the median of the three per-round p95 latencies; graph error bars show observed throughput min/max, not confidence intervals.
+A real August `GET /bench` endpoint returns a newly constructed typed JSON record. The Node reference constructs and serializes the same response. Both run on loopback with HTTP/1.1 keep-alive, 1,000 warmup requests and five fresh-server rounds of 5,000 measured requests per concurrency level. Every response must have status 200, JSON content type, and the exact expected data. The measured runs had zero errors. p95 is the median of the five per-round p95 latencies; graph error bars show observed throughput min/max, not confidence intervals.
 
 The Node load generator runs on the same machine and consumes CPU. This closed-loop test has no TLS, authentication, logging, database, outbound network calls or slow clients. Its numbers are endpoint microbenchmark throughput, not a supported production capacity or service-level guarantee. HTTP/2, HTTP/3 and streaming are not benchmarked here.
 
@@ -163,14 +183,16 @@ Place these files in one folder. Every request constructs a `Reply` and returns
 **routes.aug**
 
 ```aug project=benchmark-http file=routes.aug
+// aug-spec: "routes.aug.md" explains this file. Read it before changes; refresh with aug spec.
 record Reply(int id, string message)
-endpoint GET "/bench" as reply() returns Reply:
+endpoint GET "/bench" as reply() :
     return Reply(id=7, message="hello")
 ```
 
 **main.aug**
 
 ```aug project=benchmark-http file=main.aug
+// aug-spec: "main.aug.md" explains this file. Read it before changes; refresh with aug spec.
 import reply from routes
 serve reply on port 0
 ```
@@ -181,10 +203,10 @@ serve reply on port 0
 Start the app in one terminal:
 
 ```sh
-aug run path/to/http-example
+npx @greenpandastudios/aug-cli@next run path/to/http-example
 ```
 
-Save the load generator below as `http-load.mjs`, or use `scripts/http-load.mjs` from a repository checkout. In another terminal, replace `PORT` with the printed port. This is the **same load generator** the comparison suite uses:
+Save the load generator below as `http-load.mjs`. In another terminal, replace `PORT` with the printed port. This is the **same load generator** the comparison suite uses:
 
 ```sh
 node http-load.mjs --url http://127.0.0.1:PORT/bench \
@@ -265,7 +287,8 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1
     for (let i = 0; i < rounds; i++) {
       await httpLoad(url, concurrency, warmup, expected);
       const result = await httpLoad(url, concurrency, requests, expected);
-      delete result.latencyMs.samples; results.push(result);
+      if(!process.argv.includes('--raw-samples'))delete result.latencyMs.samples;
+      results.push(result);
     }
     const measured = statistics(results.map(result => result.requestsPerSecond));
     console.log(JSON.stringify({url, concurrency, warmup, rounds:results, requestsPerSecond:measured}, null, 2));
@@ -285,11 +308,11 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1
 
 | Workload | August | C | Node | Python |
 | --- | ---: | ---: | ---: | ---: |
-| Startup | 1.3 MiB | 1.4 MiB | 46.0 MiB | 15.1 MiB |
-| CPU · 2 million iterations | 1.3 MiB | 1.4 MiB | 52.2 MiB | 15.1 MiB |
-| Map + Set · 20,000 entries | 4.5 MiB | 4.4 MiB | 57.0 MiB | 20.2 MiB |
-| Map + Set · 200,000 entries | 34.2 MiB | 25.4 MiB | 91.1 MiB | 62.1 MiB |
-| JSON · 5,000 round trips | 1.8 MiB | 1.5 MiB | 47.4 MiB | 16.2 MiB |
+| Startup | 1.3 MiB | 1.3 MiB | 46.0 MiB | 8.4 MiB |
+| CPU · 2 million iterations | 1.3 MiB | 1.3 MiB | 52.2 MiB | 8.4 MiB |
+| Map + Set · 20,000 entries | 4.7 MiB | 4.4 MiB | 56.9 MiB | 13.2 MiB |
+| Map + Set · 200,000 entries | 36.8 MiB | 25.4 MiB | 91.1 MiB | 55.3 MiB |
+| JSON · 5,000 round trips | 1.8 MiB | 1.5 MiB | 47.4 MiB | 9.7 MiB |
 
 [benchmark-memory-end]: #
 
@@ -297,7 +320,7 @@ These are medians of three separate peak-RSS measurements through `/usr/bin/time
 
 ## Before and after
 
-The same August programs and measurement settings were run on this machine before and after the performance work. Shorter bars are faster for execution time; taller points are faster for HTTP. This compares observed application performance. [Earlier measurement summaries](benchmark-baseline.json) preserve the baseline.
+The earlier September 29 measurements and current LLVM measurements use the same August programs on this host. Versions and backends differ; the earlier HTTP run used three rounds and the current run uses five. The current suite also isolates each load client in a fresh process. This is a historical comparison of observed performance, not a controlled estimate of one compiler change. Shorter bars are faster for execution time; taller points are faster for HTTP. [Earlier measurement summaries](benchmark-baseline.json) preserve the baseline.
 
 ![August execution time and HTTP throughput before and after the performance update, using the same workloads.](./assets/benchmarks/improvements.svg)
 
@@ -305,13 +328,13 @@ The same August programs and measurement settings were run on this machine befor
 
 | August workload | Before | Current | Current relative to before |
 | --- | ---: | ---: | ---: |
-| CPU · 2 million iterations | 36.65 ms | 7.24 ms | 5.06× faster |
-| Map + Set · 20,000 entries | 4.68 ms | 2.54 ms | 1.84× faster |
-| Map + Set · 200,000 entries | 47.90 ms | 15.10 ms | 3.17× faster |
-| HTTP · 1 clients | 25,273 req/sec | 23,526 req/sec | 0.93× throughput |
-| HTTP · 16 clients | 62,719 req/sec | 73,370 req/sec | 1.17× throughput |
-| HTTP · 64 clients | 30,693 req/sec | 65,365 req/sec | 2.13× throughput |
-| Map + Set · 200k peak memory | 61.9 MiB | 34.2 MiB | 45% less |
+| CPU · 2 million iterations | 36.65 ms | 7.74 ms | 4.73× faster |
+| Map + Set · 20,000 entries | 4.68 ms | 2.71 ms | 1.72× faster |
+| Map + Set · 200,000 entries | 47.90 ms | 16.81 ms | 2.85× faster |
+| HTTP · 1 clients | 25,273 req/sec | 21,046 req/sec | 0.83× throughput |
+| HTTP · 16 clients | 62,719 req/sec | 58,708 req/sec | 0.94× throughput |
+| HTTP · 64 clients | 30,693 req/sec | 54,436 req/sec | 1.77× throughput |
+| Map + Set · 200k peak memory | 61.9 MiB | 36.8 MiB | 40% less |
 
 [benchmark-improvements-end]: #
 
@@ -322,50 +345,20 @@ The same August programs and measurement settings were run on this machine befor
 3. Measure a release executable repeatedly. Compilation is excluded; process startup is included.
 
 ```sh
-aug check path/to/project
-aug run path/to/project
-aug bench path/to/project --iterations 20 --warmup 3 --json > benchmark.json
+npx @greenpandastudios/aug-cli@next check path/to/project
+npx @greenpandastudios/aug-cli@next run path/to/project
+npx @greenpandastudios/aug-cli@next bench path/to/project --iterations 20 --warmup 3 --json > benchmark.json
 ```
 
 `aug bench` compiles with release optimization even when the project's normal setting is debug. Do not benchmark `aug run`: that command includes compiler work. Server programs run indefinitely, so use an HTTP load generator against a built server instead of `aug bench`. Record errors and latency as well as throughput. The comparison suite validates checksums; `aug bench` itself checks exit status, so verify your program's result first.
 
-## Reproduce the comparison graphs
-
-From a checkout, with Node 24+, Python and a C11 compiler:
-
-```sh
-npm ci
-node scripts/bootstrap-native.mjs
-npm run bench:compare
-```
+## Reproduce the programs
 
-Set `AUG_BENCH_PYTHON=/path/to/python3` or `CC=/path/to/clang` to select the reference interpreter/compiler. `AUG_NATIVE_HOME` selects the native dependency cache. The raw result file records versions and a source fingerprint. Compilation timings are included separately from executable run time.
+Download a [measured project](examples/index.md#measured-programs), extract it, and prepare [native dependencies](packages.md#npm-registry). Each download contains the code and configuration shown in the gallery. Run finite programs with the commands under [Benchmark your own project](#benchmark-your-own-project); use [the HTTP load generator](#http-program) for the server. The complete C, Node, and Python reference programs are below, so you can save and inspect the comparison code too.
 
-For core/JSON only, extract the smaller native source dependencies and omit HTTP:
-
-```sh
-node scripts/bootstrap-native.mjs --extract-only --only minicoro,yyjson
-npm run bench:compare -- --skip-http
-```
-
-The full suite writes `docs/benchmark-results.json`; a core-only run writes `.aug-build/benchmarks/results-core.json` and preserves the complete wiki measurements. Focus on selected workloads while trying your own changes:
-
-```sh
-npm run bench:compare -- --only cpu,collections-200k
-npm run bench:compare -- --only http --http-requests 10000
-```
-
-Focused runs write `.aug-build/benchmarks/results-focused.json`. Use `--output PATH` to keep separate reports. Render graphs, tables and the exact source examples from the full result file using Python 3.12+:
-
-```sh
-python3 -m venv .aug-build/benchmark-plotting
-.aug-build/benchmark-plotting/bin/python -m pip install -r benchmarks/plot-requirements.txt
-.aug-build/benchmark-plotting/bin/python scripts/render-benchmarks.py
-.aug-build/benchmark-plotting/bin/python scripts/render-benchmarks.py --check
-npm run docs:build
-```
+The 200,000-entry collection run changes `20000` to `200000` in the downloaded Map/Set program. Keep the matching input count in each reference implementation and verify the published checksum before comparing timings. Record the machine, compiler, toolchain version, input size, and flags with your results.
 
-The plot environment is isolated and ignored; published documentation includes the rendered graphs and needs no Python installation. Review this page's environment, interpretations and limitations when replacing measurements. Short exploratory runs can use `--iterations 3 --warmup 1 --http-rounds 1 --http-requests 1000`; they have less statistical coverage.
+[Maintaining the comparison suite](contributing-benchmarks.md) describes the contributor workflow that produces the full graphs, raw samples, and checked source panels.
 
 ### Comparison implementation sources
 

package/docs/production-readiness.md

@@ -1,10 +1,10 @@
 # Production readiness and dependencies
 
-August 0.19 is experimental. The compiler, CLI, packages, standard declarations, and editor can be tried today; the project does not claim general production readiness. Use the [getting-started guide](getting-started.md) for a first application, [the roadmap](roadmap.md) for release gates, and [the compatibility page](compatibility.md) for the proposed 1.0 support contract.
+August 0.20 is experimental. The compiler, CLI, packages, standard declarations, and editor can be tried today; the project does not claim general production readiness. Use the [getting-started guide](getting-started.md) for a first application, [the roadmap](roadmap.md) for release gates, and [the compatibility page](compatibility.md) for the proposed 1.0 support contract.
 
 ## What is measured and verified
 
-The repository checks compiler types, native execution, language examples, generated specs, package installation outside the checkout, and the VS Code extension in CI. [Performance measurements](performance.md) compare specific programs and HTTP loads on named hardware. A benchmark is evidence for that program and environment, not a general speed guarantee.
+The repository checks compiler types, native execution, language examples, generated specs, package installation in isolated projects, and the VS Code extension in CI. [Performance measurements](performance.md) compare specific programs and HTTP loads on named hardware. A benchmark is evidence for that program and environment, not a general speed guarantee.
 
 The [robustness tests](../tests/robustness.test.mjs) mutate 5,000 source files through the parser and 1,000 through project checking, then compare generated native integer, Map, and Set programs in debug and release modes with independent JavaScript oracles. CI also runs [core native stress programs](../scripts/sanitize-core.mjs) for collections, task joining, and owned `Shared<T>` transfer with AddressSanitizer and UBSan on macOS and Linux. Run them locally with `npm run test:sanitizers`. This catches specific crashes, wrong results, and memory errors in the exercised paths; it does not prove the compiler, HTTP/crypto libraries, or all programs safe. Leak detection is disabled for this gate because the macOS AddressSanitizer runtime does not support it.
 
@@ -12,10 +12,13 @@ The same-app [OpenID Connect example](examples/oidc-login/index.md) proves integ
 
 ## Dependencies and licenses
 
-The npm CLI and three August library packages have **no npm production dependencies outside their matching August packages**. The VS Code extension's npm audit currently reports zero advisories. The wiki build uses VitePress and a pinned Vite override; run `npm audit` before each release. npm audit only covers npm packages and cannot certify native code or deployment configuration.
+The [safety gyms](safety-gyms.md) now collect generated LLVM cases, rejected contracts, behavioral mutations and the larger runtime circuits in one replayable report. [Recorded qualification](qualification-results.md) shows the actual execution counts and skipped checks. The expanded performance suite measures eight further programs against C. These checks strengthen the release evidence without establishing universal safety or speed.
+
+The CLI uses its matching core August library and `tar` 7.5.22 for registry archive extraction. The extension bundles that parser and its JavaScript dependencies. The VS Code extension's npm audit currently reports zero advisories. The wiki build uses VitePress and a pinned Vite override; run `npm audit` before each release. npm audit only covers npm packages and cannot certify native code or deployment configuration.
 
 | Dependency | Role | License from upstream | Distribution consideration |
 | --- | --- | --- | --- |
+| tar, chownr, yallist, minipass, minizlib, @isaacs/fs-minipass | Archive extraction in the CLI and extension | ISC, MIT, or BlueOak-1.0.0, as recorded in each package | Preserve the bundled license files and review npm audit before release. |
 | minicoro | Portable task runtime source | Public domain or MIT No Attribution | Source is fetched with a checked SHA-256. |
 | yyjson | JSON source | MIT | Source is fetched with a checked SHA-256. |
 | libwebsockets | Native HTTP library | MIT core; bundled portions have their own notices | Static link in a full native build; preserve applicable notices. |
@@ -30,10 +33,18 @@ The exact versions, archive URLs, and SHA-256 values are in [`native-dependencie
 
 ## Release gates still open
 
+The [LLVM/native candidate](native-implementation.md) supports real repository
+imports of CPU LibTorch, SQLite, zlib and Rust BLAKE3 on macOS ARM64 and
+GNU/Linux x86-64/ARM64 with glibc 2.36+. Installed CLI checks cover public
+downloads, exact locks, offline reuse, relocated bundles and finite ownership
+cases without native tools or development headers. Language parity, DWARF and
+core sanitizers are implemented. The 0.21.0 candidate selects LLVM by default;
+its updated platform gates and public compiler release remain pending.
+
 - **Platform support:** the full pinned web/crypto bootstrap passes on macOS ARM and Linux ARM. [Docker build/run bases](docker.md) run core, web, and crypto programs on Linux. Linux x86-64 runs in CI; other platforms remain unverified.
 - **Concurrency and ownership:** tasks use one OS thread. The [conformance suite](language-conformance.md) exercises injected captures, mutation after a child starts inside `borrow`, owned `Shared<T>` cleanup, branch joins, cancellation, and the public `Task<T>` error contract. A 1.0 support claim still depends on the platform, distribution, and compatibility gates.
 - **Security and reliability:** HTTP and OIDC need broad protocol conformance, durable credentials and keys, rotation, long-running load tests, and deployment guidance. The [gap ledger](web-library-gaps.md) records the precise work.
-- **Package and ABI stability:** published npm identities, reproducible releases, compatibility policy, and native adapter ABI need stable release gates.
+- **Package and ABI stability:** the [matching 0.19.0 npm packages](packages.md#npm-registry) are published and their core starter workflow is verified. Reproducible releases, compatibility policy, and native adapter ABI still need stable release gates.
 - **Operational behavior:** failure handling, cancellation, instrumentation, platform builds, and resource ceilings need repeated CI and field testing.
 
-For a trial deployment, pin the compiler and native lock, run the project's tests and `aug spec --check`, review the generated C/native linker inputs, and validate the executable under your own load and failure conditions. Track the [gap ledger](web-library-gaps.md) before promising production service levels.
+For a trial deployment, pin the compiler and native lock, run the project's tests and `aug spec --check`, review its native artifact and deployment inputs, and validate the executable under your own load and failure conditions. Track the [gap ledger](web-library-gaps.md) before promising production service levels.

package/docs/qualification-results.md

@@ -0,0 +1,66 @@
+---
+generatedBy: scripts/render-qualification.mjs
+---
+# Extended performance and safety results
+
+These results cover the August 0.21.0 candidate on **Apple M5**, darwin 25.6.0 arm64, recorded 2026-10-02. August uses LLVM 23.1.2. Every measured result matched its required output. They do not establish a general C-speed or production-safety guarantee.
+
+## Eight more C comparisons
+
+::: benchmark-chart
+
+![Median August and C execution times for eight programs. Each panel has its own scale; lower is better.](assets/benchmarks/kernels.svg)
+
+![Median August and C execution times, arranged vertically for smaller screens. Lower is better.](assets/benchmarks/kernels-mobile.svg)
+
+:::
+
+Each value is the median of 30 fresh executable processes after 3 warmups. Order rotates within a separate measurement process. Timings include startup and exclude compilation. Both implementations use O2 without LTO or fast-math. [Raw samples, build times and code sizes](kernel-results.json) also include the same August programs compiled through the C migration backend.
+
+| Program and code/spec | Work per run | August | C | August / C |
+| --- | ---: | ---: | ---: | ---: |
+| [Floating-point loop](examples/float-benchmark/main.md) | 1,000,000 | 2.29 ms | 1.69 ms | 1.36 |
+| [Labeled function calls](examples/calls-benchmark/main.md) | 200,000 | 2.34 ms | 1.77 ms | 1.33 |
+| [List traversal](examples/list-benchmark/main.md) | 100,000 | 1.99 ms | 1.20 ms | 1.66 |
+| [String processing](examples/strings-benchmark/main.md) | 20,000 | 9.30 ms | 2.67 ms | 3.48 |
+| [Map deletion and refill](examples/map-churn-benchmark/main.md) | 4,000 | 4.78 ms | 4.18 ms | 1.14 |
+| [Checked failures](examples/errors-benchmark/main.md) | 20,000 | 1.37 ms | 1.13 ms | 1.21 |
+| [Record allocation](examples/records-benchmark/main.md) | 50,000 | 9.40 ms | 2.01 ms | 4.66 |
+| [Task scheduling](examples/tasks-benchmark/main.md) | 2,000 | 3.89 ms | 1.19 ms | 3.27 |
+
+Ratios above 1 mean August took longer. The C references use concrete values and explicit cleanup. Their ordered map uses linear searches and their task case makes sequential calls; it does not pay for a scheduler. The string reference copies each part, while August also creates managed strings and a list. Records retain individually allocated values in both programs, with different layouts and lifetime tracking. These are visible differences, not interchangeable implementations. [Read the C references](https://github.com/GreenPandaStudios/augscript/blob/main/benchmarks/kernels.c) before drawing conclusions.
+
+The float program checks its exact accumulated binary-fraction result. The call loop carries each result into the next call. Lists and records retain data and read it afterward. Map deletion checks reinsertion order as well as values. Error cases verify both the sum and number of failures; task cases verify the joined sum. Their [downloadable projects](examples/index.md#measured-programs) show code beside compiled specs in either indentation or braces style.
+
+## Safety qualification
+
+Seed **877966**, generator version **1**, 256 generated vectors per exercise plus fixed edge cases. Both development and optimized LLVM builds ran the corpus.
+
+| Exercise | Vectors executed across both builds | Result |
+| --- | ---: | --- |
+| arithmetic | 516 | Passed; both behavioral mutations detected |
+| floating-point | 520 | Passed; both behavioral mutations detected |
+| collections | 516 | Passed; both behavioral mutations detected |
+| control-flow | 516 | Passed; both behavioral mutations detected |
+| checked-bounds | 520 | Passed; both behavioral mutations detected |
+| cleanup | 512 | Passed; both behavioral mutations detected |
+| tasks | 512 | Passed; both behavioral mutations detected |
+
+The suite executed **3612 generated/edge-case checks**, rejected **8 forbidden contracts**, and detected **14 valid behavioral mutants**. Each mutant compiled and ran safely; its wrong result or cleanup count differed from the independent oracle.
+
+| Additional circuit | Executed tests | Skipped tests | Result |
+| --- | ---: | ---: | --- |
+| source-mutations | 3 | 0 | passed |
+| ownership-concurrency | 53 | 0 | passed |
+| native-boundaries | 2 | 0 | passed |
+| package-integrity | 19 | 0 | passed |
+| http-boundaries | 6 | 0 | passed |
+| sanitizers | 4 instrumented programs + LLVM negative control | 0 | passed |
+
+[The full report](gym-results.json) includes original and faulty source units, inputs, expected and actual results, cleanup counts, compiler source identity and commands. Source mutation includes 5,000 parser cases and 1,000 checker cases. Core sanitizers instrument August LLVM accesses and the C runtime; they do not instrument the interiors of prebuilt foreign libraries or establish a whole-process leak proof.
+
+The [safety gym guide](safety-gyms.md) explains each gate and its limits. [Contributor commands](contributing-benchmarks.md) reproduce these reports or explore another seed. New-platform CI reports remain separate until that target completes qualification.
+
+## Source identity
+
+Both reports use source SHA-256 `23c9155410c0af115173e99c583e86374df5b83e22d9ce82aeabeb19405384a0`. This fingerprints compiler, runtime, native platform inputs, package contracts, configuration, dependencies, test fixtures, generators and measured programs. Recorded evidence remains tied to that snapshot; a later change requires a new run.