Gooo policy composition: standalone Go header demo

Try an original Gooo language composition from an ordinary Go project. The attached gooo-header-addition-demo.tar contains the exact generated Go, five authored Gooo sources, license notices, independent expected cases and generation provenance. Running this snapshot needs Go 1.27.2 and no Gooo installation or module download.

The example combines header diagnostics, payload admission and current request observations. Its local owner reassesses an eligible diagnostic header and applies it once while advancing the request revision under the same lock. Each request needs no human approval.

Download both attached files into an empty directory, verify the archive and run:

shasum -a 256 -c SHA256SUMS
tar -xf gooo-header-addition-demo.tar
cd gooo-header-addition-demo
GOTOOLCHAIN=local GOWORK=off GOENV=off GOPROXY=off GOSUMDB=off go run .

Select Go 1.27.2 on PATH first. The result prints APPLIED, request revision 1→2 and all 16 decision fields. See the included README and domain contract before adapting it.

Generation source: 96dba0e3, PR #105. The original main CI passed 74 suites, 171,217 cases and 2,181 batches, including native execution and saved replay. A separate Go-only consumer on macOS arm64 passed all 50 independent expected cases (800 decision fields), vet, all 18 tests with the race detector, build and the actual revision 1→2 demo. The portable snapshot retains the original generated bytes; it is a runnable demo, not an importable SDK.

This example owns one buffered request in local memory. The host still supplies authenticated current facts. It does not implement network authentication, persistence or distributed transactions, and does not make a production-safety guarantee. The comparison receipts establish the documented finite checks; independent inner typed canonical parent validation remains NOT_CHECKED.

Literal text search and standalone browser demos

Try literal text search in your browser, or serve the standalone browser archive over local HTTP without installing a compiler. It reports the first UTF-8 byte offset and non-overlapping match count; each input supports up to 1,024 UTF-8 bytes.

Live demo · Gooo language

Download the browser archive and START-HERE.txt to run locally. The separate source archive includes the native workspaces and upstream licenses; a native compiler is not bundled. The source editor generates Go without executing it.

Main CI passed 21 native gates, 62 suites, 159,781 finite cases and 2,332 saved execute/replay batches, plus eight browser reports. The relocated browser archive also passed 48 Wasm and 48 production Worker observations and local HTTP checks. These checks do not include a full browser DOM or layout test.

Downloaded browser reports are unsigned observations, separate from native receipts and replay checks. Checksums establish byte consistency, not signatures. Detailed scopes and exact pins are in PROVENANCE.json and release-notes.txt.

Release tag CI also passed the full native and browser checks at the same source commit. Pages packaging and deployment were skipped for the tag, as configured; the live demo comes from the verified main deployment.

Thanks to @KeuqS for clarifying the generated-Go boundary in the README.

Prepared by asketeddy asketeddy@gmail.com with Codex assistance.

v0.1.0-preview.8: UUID, byte search and strict crop requests

Check UUID text, find a byte in UTF-8 text, and reject crop requests that extend outside the supplied bounds with executable Gooo examples. Compared with preview.7, this source snapshot adds Google UUID Validate/ParseCanonical adaptations, bounded strings.IndexByte, and Rectangle.In/FitsCrop. The hosted source editor also lets you save the current generated Go and original response JSON.

Try the Gooo source editor: select clamp, change return 0 to return 7, generate Go, then download the result. It generates Go for one activity and does not execute the generated program. The editor loads about 22 MB, accepts one UTF-8 source file up to 64 KiB, and has no package imports or model-provider calls.

For native execution, download gooo-go-ports-265eeb4-source.tar.gz and START-HERE.txt. The source archive contains the runnable workspaces, input examples, setup scripts and upstream license notices. Start with UUID canonical parsing, then follow the included example READMEs for UUID format checks, byte search or FitsCrop. Git, a POSIX shell and a Go installation supporting toolchain selection are required; bootstrap may download the pinned compiler and Go 1.27.2. Python 3 is additionally needed for the FitsCrop checker. Rebuilding the browser site requires a Git checkout at the exact source commit.

UUID inputs are valid UTF-8 Text up to 1,024 bytes. These are Text adaptations of google/uuid v1.6.0, not the complete binary UUID API. Check parsed before using canonical_uuid: a parse error can still return partial UUID data. Byte search preserves UTF-8 byte offsets within the same text bound; needle integers outside 0..255 return -1 as a separate extension. Rectangle coordinates preserve signed int64 values on supported 64-bit targets. Rectangle.In accepts an empty receiver; FitsCrop separately rejects empty requests and never clips coordinates or processes pixels.

Exact source: 265eeb4. Compiler: Gooo 0.6.32-dev at 83928fa4538245abe33b08549da47f8cbdc50ed2. Go: 1.27.2. PROVENANCE.json binds source file hashes, archive checksums, toolchain identities and the CI gate state. ARCHIVE-VALIDATION.json summarizes the relocated UUID and FitsCrop execute/replay check; raw native receipts are not bundled. The exact-source main CI passed 131,842 finite Go-reference comparisons across 59 suites and 1,777 execute/replay batches. The separate full tag CI also passed the same 59-suite corpus and all saved replays. FitsCrop 14 input-only observations and 90 malformed-input rejections are separate checks and are not added to that reference total. Historical execution receipts included in the source retain their own recorded revisions and are not relabeled as this release's execution. Checksums establish byte consistency; no signed attestation is claimed.

한국어: 소스 묶음과 START-HERE.txt를 내려받아 UUID 예제를 실행하고 저장된 기록을 다시 실행할 수 있습니다. 브라우저 편집기에서는 생성된 Go와 원본 응답을 저장할 수 있지만, 생성된 프로그램은 실행하지 않습니다. 문제를 만났다면 문제 제보에 실행 환경과 오류를 알려 주세요.

Experimental function-level ports over stated domains; finite observations do not establish whole-library compatibility, production safety, customer adoption or a performance advantage. Independent project with no official Google/Go affiliation. Thanks to @KeuqS for clarifying the generated-Go boundary in the README. Project-affiliated release by asketeddy; OpenAI Codex assisted development, validation and packaging.

v0.1.0-preview.7: source editing, alpha matte and replayable evidence

Edit a Gooo source file in your browser and inspect the generated Go. This preview adds the actual compiler-library editor, saved CLI source examples, and native NRGBA/alpha-matte examples to the pinned Go-ports collection.

Start with the hosted source editor or download the browser archive below. Select clamp, change return 0 to return 7 in Source, click Generate Go, and inspect the generated branch. The editor generates Go for one activity; it does not execute the generated program. Imports, models, providers and the full CLI are outside this browser adapter. The source limit is 64 KiB UTF-8; the first load uses about 22 MB.

Choose a download:

• gooo-go-ports-v0.1.0-preview.7-browser-demo.tar.gz: compiled browser tools, the source editor and their original CI evidence. Extract it, keep the version directory name, and follow README.txt to serve it over localhost HTTP. Native-only examples are not browser execution features.
• gooo-go-ports-v0.1.0-preview.7-source.tar.gz: exact source and native examples. Native setup needs Git, a POSIX shell and Go 1.27.2, and bootstrap downloads the pinned compiler/dependencies. Rebuilding the browser site requires a Git checkout at the release commit.
• gooo-go-ports-v0.1.0-preview.7-native-evidence.tar.gz: original Linux execution/replay batches and individually scoped exhaustive reports.
• gooo-go-ports-v0.1.0-preview.7-policy-evidence.tar.gz: separate synthetic Gooo execution/replay and mock-dispatch traces; no model-provider calls or customer results.
• PROVENANCE.json and SHA256SUMS: source, CI, artifact and file-hash bindings. Checksums verify byte consistency; no signed attestation is claimed.

The exact source is 44fbcd5bb58104aa0f338052d99d87478eb8ce80. Main CI passed 62,241 finite cases across 52 suites and 833 execute/replay batches, covering 36 selected function ports, 14 importing programs and 16 activities. Separate exhaustive function checks retain their own domains; their counts are not added as unique coverage. Original receipt bytes, exact numeric tokens and license notices are preserved.

The compiler remains Gooo 0.6.29-dev, revision 90ff2bb5aeffc2ac553496b646d14db1e8d33fdb, with Go 1.27.2. The saved source book retains its earlier evidence revision. The editor's compiler report remains UNBOUND_LOCAL_SOURCE; its separate build manifest identifies the pinned library and bridge. Archive smokes and relocated alpha-matte execute/replay checks passed; the final browser archive was also checked in Chrome, including a real source edit and error recovery.

한국어: 설치 없이 위 소스 편집기에서 첫 수정을 해 볼 수 있습니다. 다운로드한 브라우저 묶음도 사용할 수 있으며, 실행 순서는 포함된 README.txt를 따라 주세요. 생성된 Go 프로그램을 브라우저에서 실행하는 기능은 아닙니다. 막히면 문제 제보에 페이지 주소와 보이는 오류를 적어 주세요.

Experimental release: these observations do not establish whole-library compatibility, production safety, customer adoption or a performance advantage. Project-affiliated release by asketeddy; OpenAI Codex assisted development, validation and packaging. This is an independent project, with no official Google/Go affiliation.

v0.1.0-preview.6 — Unicode case mapping and fixed-point tools

Unicode case mapping, fixed-point pixel bounds and direction-independent drag cropping are now available in one fixed installation snapshot. For example, the native case inspector maps dž to uppercase DŽ and titlecase Dž, while preserving the original integer and separate rune-domain/scalar flags.

This snapshot contains 35 selected Go functions implemented in Gooo, 13 native importing programs (15 activities), the existing 21-function browser dispatcher, two separately compiled crop modes, a tutorial and a separate synthetic policy experiment. The compiler is pinned to Gooo 0.6.29-dev at 90ff2bb5aeffc2ac553496b646d14db1e8d33fdb, built with Go 1.27.2. Unicode case mapping, fixed-point Floor/Ceil, YCbCr and SimpleFold are native-only.

Independent experimental project maintained by asketeddy with AI assistance; not an official Google/Go release. Gooo language engine.

• source: Exact 47b47fe94b6ea4894bfb2187e062ef8862e9ba67 Git snapshot. Install Git, a POSIX shell and Go 1.27.2; select GOTOOLCHAIN=go1.27.2 and GOWORK=off, then run ./tools/bootstrap.sh from the extracted source root. Follow examples/case-inspector/README.md for the 26-input execute/replay example, and examples/fixed-pixel-bounds/README.md for fixed-point bounds and its Python 3 checker. Setup downloads the pinned compiler/dependencies. Native examples work without .git; browser rebuilding requires a Git checkout at this commit. For an existing installation, preserve the older .compiler and .gooo separately before bootstrap, as documented; it does not overwrite a mismatched compiler checkout.
• native-evidence: All 21235 original CI files, including frozen source/cases, execution/replay records, diagnostics, source catalog and exhaustive reports. Start with evidence/ci/summary.json and README.txt. Build caches are retained evidence, not a portable compiler distribution. Use relocated manifest/case paths when replaying and write results to a new file; original CI paths and bytes remain unchanged.
• browser-demo: All 138 original browser CI files plus the documented release inventory/instructions and x/image license copy. Keep the extracted version directory name, run python3 -m http.server 8766 --bind 127.0.0.1 from its parent, and open http://127.0.0.1:8766/gooo-go-ports-v0.1.0-preview.6-browser-demo/site/. The text inspector, crop planner and tutorial use the same version URL. Use HTTP, not file://, to avoid loader restrictions. Keep the new version URL to avoid stale HTML/scripts. Crop's drag mode canonicalizes the selection before clipping against original bounds; its original rectangle mode is preserved. fixed-point-bounds.html is a native usage guide. The tutorial changes fixed-program inputs; its source ZIP supports local code changes. No provider API is needed for browser calculation.
• policy-evidence: All 33 original policy CI files. Its README explains saved verification. Synthetic context and mock dispatch observations are separate from port compatibility; no real provider, export or authentication was used.

Choose the archives you need. PROVENANCE.json describes their sources and checks, and SHA256SUMS lists their hashes. If you download all four archives and PROVENANCE.json, verify them together with shasum -a 256 -c SHA256SUMS on macOS or sha256sum -c SHA256SUMS on Linux. For a partial download, compute each downloaded file’s SHA-256 and compare it with that file’s line in SHA256SUMS. Evidence/browser archives also contain FILES.sha256. Hashes and receipts establish byte consistency, not signatures or independent attestation. CI payload bytes are unchanged; source is an exact Git archive. Archive file times use the source commit time; gzip header time is zero.

The successful main CI run used this exact source and the compiler/Go pins above. Original ZIP sizes and SHA-256 digests matched GitHub artifact metadata.

• Native receipts: 57,251 cases across 50 suites and 719 execute/replay batches. The previous 37,232-case corpus is retained. Case mapping adds 16,208 port Go-reference comparisons and 198 separate extensions, plus 3,602 consumer reference comparisons and 11 extensions. Invalid To selectors account for 132 reference and 132 extension observations already included in those totals.
• Case-mapping range checks: The unchanged generated Go is compared with the pinned Go functions for every value in 0..0x10FFFF, including surrogates. To is checked for selectors 0, 1 and 2, and each unary mapping separately: 6,684,672 comparisons. Other signed-int32 inputs, invalid selectors and outside-int32 extensions are separately counted finite samples. This does not exhaust int32/int64 inputs or consumer records and does not provide whole-string, locale-specific, multi-rune casing or normalization.
• Fixed-point/drag changes since preview.5: RectangleCanon and drag cropping preserve original signed-int64 coordinates. The two Floor/Ceil ports use byte-preserved golang.org/x/image source at b06f1de3f4900ff828b8f114c37eb9ea10dfed90. PixelBounds checks raw domain and original empty/reversed selections before quantization, and rejects nonempty maxima that would overflow upstream Ceil. No 2^32 exhaustive, font rendering or image processing claim is made.
• Retained separate checks: YCbCr compares all 16,777,216 byte triples per function; SimpleFold and Unicode classification retain their own range checks. Dispatcher: 16036 reference comparisons, 483 rejection checks and 261 native seeds in 5 batches. Text, original crop, drag crop, tutorial and policy observations are recorded separately in PROVENANCE.json.

The verification catalog is distinct from runnable compiler manifests. Each suite uses all port packages and its selected consumer, preserving source/entry/receipt bindings without mixing unrelated consumer records. The source archive includes both the catalog and runnable example workspaces.

Counts overlap and are not summed as unique coverage. Browser smoke is not a DOM interaction test. These checks establish no whole-package compatibility, production-security, customer-adoption, performance or image-quality claim.

Licenses/notices are retained: BSD-3-Clause for the ports and pinned Go/x/image sources, CC-BY-SA-3.0 for tutorial source/input/workspace files, and MIT for docs/whitespace-comparison. The Learn X in Y Minutes contribution remains pending independent review; inclusion does not imply endorsement. Previous release tags and download assets remain unchanged.

If an example fails, report the input/command and observed result using information that can be public.

v0.1.0-preview.5

RGB ↔ Y′CbCr conversion and a native round-trip inspector, preserving the pinned Go integer rounding and channel saturation. For example, pure red (255, 0, 0) converts back as (254, 0, 0); the inspector shows the intermediate channels, restored RGB, signed differences and exact-match flag.

This snapshot contains 28 selected Go functions implemented in Gooo, 11 native importing programs (12 activities), the existing 21-function browser dispatcher, and a separate synthetic policy experiment. The new YCbCr functions and inspector are native-only. They process channel values, not image files, JPEG compression, chroma subsampling or color profiles.

Independent experimental project maintained by asketeddy with AI assistance; not an official Google/Go release. Gooo language engine.

• source: Exact 7269c5acde55ae62d247838b736408c28dbead94 Git snapshot, including the verification source catalog and runnable YCbCr example. Install Git and Go 1.27.2; run ./tools/bootstrap.sh from the extracted source root, then follow examples/ycbcr-inspector/README.md for execute, saved replay and the twelve-input checker. The checker also requires Python 3. Setup downloads the pinned compiler/dependencies. Native examples work without .git; browser rebuilding requires a Git checkout at the release commit.
• native-evidence: All 10733 original CI files, including frozen source/cases, execution/replay records, diagnostics, source catalog and exhaustive reports. Start with evidence/ci/summary.json and README.txt. Build caches are retained evidence, not a portable compiler distribution. Receipts retain original CI paths; use the relocated manifest/case paths in the archive README and write replay output to a new file.
• browser-demo: All 117 original browser CI files. Keep the extracted version directory name, run python3 -m http.server 8766 --bind 127.0.0.1 from its parent, and open http://127.0.0.1:8766/gooo-go-ports-v0.1.0-preview.5-browser-demo/site/. text-inspector.html, crop-planner.html and tutorial.html are under that same URL. Use HTTP, not file://, and keep the version URL to avoid stale HTML/scripts. Crop composes RectangleIntersect + RectangleEmpty; YCbCr and SimpleFold remain native-only. The tutorial edits fixed-program inputs; its source ZIP supports code changes locally. No provider API is needed for browser calculation.
• policy-evidence: All 33 original policy CI files. Its README explains saved verification. Synthetic context and mock dispatch observations are separate from port compatibility; no real provider, export or authentication was used.

Download the four archives, PROVENANCE.json and SHA256SUMS together. Run shasum -a 256 -c SHA256SUMS on macOS or sha256sum -c SHA256SUMS on Linux. Evidence/browser archives contain FILES.sha256. Hashes and receipts establish byte consistency, not signatures or independent attestation. CI payload bytes are unchanged; source is an exact Git archive. Archive file times use the source commit time and gzip header time is zero.

The successful main CI run used this exact source and unchanged compiler 366ee6ef8f9d2b9b57331dfd26b6f908c0289851 / Go 1.27.2 pins. Original ZIP sizes and SHA-256 digests matched GitHub artifact metadata.

• Native receipts: 34,170 cases across 40 suites and 465 execute/replay batches. Existing 31,014 input/expectation cases remain in the corpus. New YCbCr ports add 2,160 Go-reference comparisons and 48 out-of-byte rejections; the importing inspector adds 924 Go-reference comparisons and 24 rejections. Inputs are checked before any byte cast and rejection cases are counted separately.
• YCbCr exhaustive checks: Each unchanged generated Go conversion is compared with the pinned Go function on all 16,777,216 valid byte triples: 33,554,432 comparisons across both functions. These are separate from the receipt counts. Each report binds the generated source and fixed output-byte digest. This does not exhaust consumer round trips or out-of-domain int64 inputs, establish all runtime targets, or prove lossless conversion or whole-package compatibility.
• Other checks: SimpleFold retains its separate generated-Go coverage over all 1,114,112 values in 0..0x10FFFF, plus finite extension samples. Dispatcher: 16036 Go-reference comparisons, 483 rejection checks and 261 native seeds in 5 batches; shared-input checks reuse its reference cases. Text, crop, tutorial, Unicode-classification and policy scopes remain separately recorded in their own reports and PROVENANCE.json.

The verification catalog is distinct from runnable compiler manifests: each suite uses all port packages and its selected consumer, keeping unrelated consumer records outside that generated workspace while retaining source/entry/receipt bindings. The source archive includes both catalog and runnable example workspaces.

Counts overlap and are not summed as unique coverage. Browser smoke is not a DOM interaction test. These checks establish no production-security, customer-adoption, performance or image-quality claim.

Licenses/notices are retained: BSD-3-Clause by default, CC-BY-SA-3.0 for tutorial source/input/workspace files, and MIT for docs/whitespace-comparison. The Learn X in Y Minutes contribution remains pending independent review; inclusion does not imply endorsement.

If an example fails, report the input/command and observed result using information that can be public.

v0.1.0-preview.4: tutorial, crop planner, and receipt checks

Fixed downloads for receipt validation fixes, native Unicode SimpleFold, the browser crop planner, and the score-and-label tutorial. The snapshot contains 26 selected Go functions implemented in Gooo, 10 native importing programs, the existing 21-function browser dispatcher and a separate synthetic policy experiment.

Receipt readers now reject repeated decoded JSON object-key names, including escaped spellings and nested objects, before typed decoding. Exact integer comparisons are preserved. Case-distinct and normalization-distinct keys remain separate; this is not receipt authentication or a production-security claim.

Independent experimental project maintained by asketeddy with AI assistance; not an official Google/Go or TypeSafe release. Gooo language engine.

• browser-demo: All 115 original CI files. Extract without renaming the version directory, run python3 -m http.server 8766 --bind 127.0.0.1 from its parent, and open http://127.0.0.1:8766/gooo-go-ports-v0.1.0-preview.4-browser-demo/site/. Beside the dispatcher, open text-inspector.html, crop-planner.html or tutorial.html under that same URL. Crop composes RectangleIntersect + RectangleEmpty and handles coordinates only; SimpleFold remains native-only. The tutorial runs a fixed program; use site/tutorial/source.zip and its README to edit and execute locally after installing the pinned compiler. Browser computation needs no remote provider API. Use HTTP, not file://, and keep the new version URL to avoid older cached HTML/scripts.
• source: Exact 7d320b71fe79fd8fce2b5618c258e6a74f2a884b Git snapshot. Install Git and Go 1.27.2, then run ./tools/bootstrap.sh before native examples. Setup downloads the pinned compiler/dependencies. The source archive has no .git; rebuilding the browser needs a checkout at the release commit. The prebuilt browser archive works directly.
• native-evidence: All 10,812 original CI files, including frozen cases, sources, execute/replay records, diagnostics and build caches. Start with evidence/ci/summary.json and README.txt.
• policy-evidence: All 33 original policy CI files. Its README explains saved verification; synthetic context and a mock operation are separate from port compatibility.

Download the four archives, PROVENANCE.json and SHA256SUMS together. Run shasum -a 256 -c SHA256SUMS (macOS) or sha256sum -c SHA256SUMS (Linux). Evidence/browser archives also have FILES.sha256. Hashes and raw CI receipts establish byte consistency, not signatures or independent attestation. Packaged file times use the source commit time; gzip headers use zero.

The successful main CI run used this exact commit and unchanged compiler 366ee6ef8f9d2b9b57331dfd26b6f908c0289851 / Go 1.27.2 pins. Original ZIP sizes and SHA-256 digests matched GitHub artifact metadata. Retained finite observations:

• Native: 31,014 cases across 37 suites and 400 execute/replay batches. The separate SimpleFold generated-Go check covers all 1,114,112 values in 0..0x10FFFF (including surrogates), plus finite outside-range samples; it is not added to the receipt corpus.
• Dispatcher: 16,036 reference comparisons, 483 rejection checks, 261 native seeds in 5 batches; shared-input checks reuse those 16,036 reference cases.
• Text inspector: 21 fixtures, 618 code-point observations, 3,708 compiled calls and 21 report roundtrips.
• Crop: 88 reference cases, 210 rejection checks and 12 saved native observations.
• Tutorial: 34 Wasm/native comparisons, including 4 manual examples; 4 native rejection observations, plus 14 fixture / 26 type / 3 arity rejections.
• Policy: 49 synthetic fixtures (31 Gooo/Go/manual matches + 18 host rejections); 7 allowed mock calls, no replay/compiler-error dispatches, and 1 real compiler failure probe. No live provider, real export or performance measurement.

Counts overlap and are not summed as unique coverage. Browser smoke does not establish DOM interaction coverage. No whole-package, all-input, production-security, customer-adoption or performance claim follows from these observations.

The crop guide retains the pre-SimpleFold total of 26,967; this release’s complete native corpus is 31,014 cases in 400 batches, recorded in evidence/ci/summary.json. Some original source tables also retain native-only rectangle wording; this release's separate browser crop program exposes Intersect + Empty, while the dispatcher still has 21 functions. The exact source snapshot is preserved.

Licenses/notices are retained: BSD-3-Clause by default, CC-BY-SA-3.0 for tutorial source/input/workspace files, and MIT for docs/whitespace-comparison. The Learn X in Y Minutes contribution remains pending independent review; inclusion does not imply endorsement.

If an example fails, report the input/command and observed result using information that can be public.

Gooo Go Ports v0.1.0-preview.3 — Unicode inspector and offline policy example

A fixed snapshot of the Unicode text inspector, 25 selected Go functions implemented in Gooo, and an offline policy experiment.

This preview includes Unicode whitespace/letter/digit classification, four native rectangle operations, a crop planner and a text inspector. Runtime metadata, Wasm and reference-fixture requests bypass browser caches. The browser archive retains a version-specific directory path; keep that path when serving it. Replacing older files at an identical URL can still leave older HTML/scripts cached, so this release does not promise seamless updates in place.

This is an independent experimental project developed with AI assistance, not an official Google/Go or TypeSafe release. Gooo language engine.

Choose an archive:

• browser-demo: Extract it without renaming its directory. From the parent directory run python3 -m http.server 8766 --bind 127.0.0.1, then open http://127.0.0.1:8766/gooo-go-ports-v0.1.0-preview.3-browser-demo/site/ or http://127.0.0.1:8766/gooo-go-ports-v0.1.0-preview.3-browser-demo/site/text-inspector.html. This runs 21 precompiled functions and the text inspector without a compiler. Use HTTP, not file://. Rectangle functions are native-only. Page computation uses no remote provider API; external documentation links require internet.
• source: Exact source at caca27774012738108738ca8116c8c66031207fb. Native examples require Git and go1.27.2; run ./tools/bootstrap.sh, then follow the source README. Bootstrap downloads the pinned compiler and dependencies. The compiler is not bundled. This source archive has no .git; rebuilding the browser requires a Git checkout, while the prebuilt browser archive works directly.
• native-evidence: All 8,096 original CI files, including frozen sources, cases, execute/replay receipts and boundary diagnostics. Start with evidence/ci/summary.json and README.txt.
• policy-evidence: All 33 original policy CI files in a separate archive. README.txt explains saved verification. This uses synthetic context and a mock operation, with no live model API or real export.

Download the four archives, SHA256SUMS and PROVENANCE.json together. Check with shasum -a 256 -c SHA256SUMS on macOS or sha256sum -c SHA256SUMS on Linux. Each evidence/browser archive also includes FILES.sha256; check it from the extracted directory. Hashes and receipts establish byte consistency, not signatures or independent attestation. Packaged file timestamps use the exact source commit time; gzip header timestamps are independently fixed for reproducibility.

The successful main-branch CI run used this exact commit and Gooo compiler 366ee6ef8f9d2b9b57331dfd26b6f908c0289851 with go1.27.2. Original ZIP sizes and SHA-256 digests matched GitHub artifact metadata before packaging. Retained reports record:

• Native: 26,967 finite cases across 35 suites and 363 execute/replay batches, with 9 importing programs. Go-reference comparisons and explicit extension/rejection observations are distinguished in the summary.
• Browser: 16,036 reference comparisons, 483 separate invalid-call/input checks and 261 native seed cases in 5 saved batches. Shared-input roundtrips reuse the same 16,036 reference cases.
• Text inspector: 21 text fixtures, 618 code-point observations, 3,708 compiled operation calls and 21 JSON report roundtrips. These overlapping counts are not independent coverage or a native Gooo string API.
• Policy: 49 synthetic fixtures: 31 Gooo/direct-Go/manual matches and 18 host rejections; 7 allowed mock calls; 0 replay and 0 compiler-error dispatches; 1 actual compiler failure probe. Performance was not measured.

These observations do not establish whole-package compatibility, correctness over every input, production security, customer adoption, or an advantage over direct Go with equivalent records. The text inspector classifies code points; it does not normalize text, validate whole identifiers or establish that text is safe. Licenses and pinned upstream provenance are included.

If an example fails or missing behavior blocks real work, report the input/command and observed result. Share only information that can be public.

Gooo Go Ports v0.1.0-preview.2 — durations and fixed downloads

This experimental snapshot packages 18 selected Go standard-library functions implemented in Gooo, six native importing examples (seven activities), and a standalone browser demo. Download a fixed version without needing access to expiring GitHub Actions artifacts.

Since preview.1, the snapshot adds exact signed-64-bit byte rotation counts and time.Duration.Round / Truncate, a four-field duration quantizer, color conversion in the browser, reusable-project instructions, and recovery from an interrupted compiler bootstrap. Both duration arguments are nanoseconds; nonpositive multiples return the original duration, and rounding saturates at the signed limit when necessary.

Choose a download

• source.tar.gz — exact tracked source at 7bd5b9f. Requires Go 1.27.2, Git and network access for compiler bootstrap. Includes six importing examples.
• native-evidence.tar.gz — all original Linux CI files: 14,093 finite cases in 168 execution batches with saved replays. Includes sources, inputs and output traces; no compiler executable is bundled.
• browser-demo.tar.gz — complete precompiled site, usable with a local static HTTP server. No Go installation is required to run it. Includes all 153 native build seeds across three indexed batches; top-level execution/replay files alias only the first batch.
• PROVENANCE.json and SHA256SUMS — source, compiler, CI and asset identities. Checksums detect changed bytes; they are not signatures.

Verification

Successful main CI binds these artifacts to the selected source and Gooo compiler 366ee6e (0.6.24-dev), built with Go 1.27.2. Every original native CI batch was additionally replayed after moving it to a directory containing spaces on macOS arm64: all 14,093 complete traces matched, without changing the evidence files. A fresh source archive downloaded and built the pinned compiler, then checked 14 input-only duration examples and their saved replays against an independent Go reference.

The actual WebAssembly passed 10,487 Go-reference comparisons and shared-input roundtrips, plus 301 fixture rejections and 45 additional malformed-call checks, both in CI and after relocation. The relocated site was also served over HTTP and every site file matched the distributed bytes.

Serve the browser archive’s site/ with any static server; its README includes an optional Python command. Rebuilding the browser requires a Git checkout because the builder records Git metadata. The source archive supports native bootstrap and verification.

Try the current public demo · Read the pinned source · Gooo language repository

The public demo may advance independently of this release. These are finite function-level observations, not full-package compatibility, a proof for every possible input, or a benchmark. Explicit invalid-domain extensions are separate from Go equivalence. This independent experimental project is not an official Google/Go project.

v0.1.0-preview.1 — Gooo ports with replayable evidence

This first experimental release makes the Go-to-Gooo language ports, saved execution evidence, and browser demo downloadable together at a fixed revision.

Try the public browser demo · Read the pinned source

Choose a download

Asset	Use it for
gooo-go-ports-v0.1.0-preview.1-source.tar.gz	Gooo ports, importing examples, Go reference verifier, and the pinned compiler bootstrap script. Requires Go 1.27.2, Git, and a POSIX shell to build.
gooo-go-ports-v0.1.0-preview.1-native-evidence.tar.gz	Original CI execution/replay receipts, inputs, expectations, and sources. Includes instructions to replay after moving the files. Use with the source archive to build the compiler.
gooo-go-ports-v0.1.0-preview.1-browser-demo.tar.gz	A standalone static site running 13 precompiled functions as WebAssembly. Extract, serve site/ over HTTP, and open it in a browser; no compiler installation required.
PROVENANCE.json and SHA256SUMS	Source/toolchain/CI identities, original artifact digests, and checksums for the release archives.

Download the five named assets into one directory, then verify with sha256sum -c SHA256SUMS on Linux or shasum -a 256 -c SHA256SUMS on macOS. The automatically generated GitHub “Source code” archives are not included in that checksum file.

The source archive supports the native bootstrap and verifier but contains no .git directory. Rebuilding the browser site records Git metadata: for that workflow, clone the repository and check out v0.1.0-preview.1 before following the source README. The compiled browser download can be served directly.

What was checked

• Native: 15 ported functions, four consumer programs (five activities), 5,510 cases in 80 batches, with saved replay. Cases include explicit out-of-domain rejection contracts, separate from Go-reference equivalence observations.
• Browser: 13 functions, 3,137 Go-reference comparisons and shared-input roundtrips, plus 55 input rejection checks using the actual Wasm. Color conversion remains native-only.
• Portability: all 80 archived Linux/amd64 batches replayed from a moved directory with spaces on macOS/arm64, with all 5,510 full traces matching. The standalone site also passed its checks after relocation.
• Distribution: original receipt bytes are preserved; licenses and upstream notices are included. The downloaded original CI ZIP digests match GitHub's artifact metadata. Source and runtime files are tied to the exact successful main CI run.

Source commit: e650b7900d29b5590d4f3daebba1f2d88b519c52. Compiler: Gooo 0.6.24-dev at 366ee6ef8f9d2b9b57331dfd26b6f908c0289851. Go: 1.27.2.

This is an independent experimental project, not an official Google/Go project or a complete Go package implementation. Six byte-domain functions cover all 256 inputs each; larger domains use finite boundary cases and deterministic samples. Color conversion preserves integer rounding and does not provide ICC color-profile or printer calibration. Checksums detect byte changes; they are not signatures or proofs of correctness.

If you try it, a useful issue report includes the release version, operating system, function/input, and actual versus expected behavior. Please remove private data from any attached logs.