Ghi v0.2.11

Source diagnostics

• Restore original Ghi columns for type errors inside and after lowered expressions, including nested ternaries and Unicode source.
• Report ternary conditions and branch mismatches in Ghi terms.
• Show nullable classes as ?Class, including imported aliases, without generated Go pointer-to-interface details; preserve native pointer types.
• Add actionable CLI hints for conditions, ternary syntax, nullable checks and call argument counts; preserve plain editor location headers.

Full compiler tests and vet passed on Windows amd64. Existing Request Journal passed Ghi Quality run and format checks, with one reviewed intentional empty catch warning and no automatic changes. Its fresh-consumer integration and HTTP workload passed 4,488 verified responses, 320 cascading deletes and 162 records plus histories surviving restart, including SQLite lock and disconnect checks.

Six portable archives, Windows setup and macOS installer build kit included. Mojave remains v0.1.0. Installers are unsigned; macOS kit is not a native .pkg. Native Mac/Homebrew runtime validation remains deferred. Check downloads against checksums.txt.

Ghi v0.2.10

Conditional expressions

• Add condition ? trueValue : falseValue with strict bool conditions, compatible inferred result types and lazy branches.
• Preserve nullable ?Type, generic/default arguments, closures, exception propagation and original source coverage.
• Require parentheses around nested ternaries; shorthand ?: is not supported.
• Canonical formatting, English language documentation and runnable examples/ternary included.

Compiler tests and vet passed on Windows amd64. Release binaries created and executed a new project and the ternary example on Windows/Linux amd64. Linux ARM64 syntax analysis passed under emulation. Ghi Quality v0.1.1 and GoLand 251/262 compatibility checked.

Six portable archives, Windows setup and a macOS installer build kit are included. Mojave remains v0.1.0. Installers are unsigned. The macOS kit is not a prebuilt .pkg; native macOS/Homebrew checks remain deferred. Verify downloads against checksums.txt.

Ghi v0.2.9

Source analysis for quality tools

• Add ghi analyze --json source.ghi and stdin analysis with a diagnostic filename.
• Versioned schema1 reports exact original UTF-8 byte spans, token text, delimiter pairs and source SHA256.
• Ghi parser validates syntax; malformed input returns JSON diagnostics without partial tokens/capabilities. This syntax API does not resolve symbols or types.
• Analysis does not install Go, load dependencies, write source files or create a build workspace.
• Harden analysis of extracted class type fragments. Byte-contract tests cover Unicode, BOM, CRLF, raw strings, comments, nullable tokens and malformed source.

Full compiler tests and vet passed on Windows amd64; targeted regressions rerun after review fixes. Linux amd64 and emulated ARM64 syntax analysis verified without Go. Native macOS/Homebrew checks remain deferred.

Six portable archives, Windows setup and a macOS installer build kit are included. Mojave remains v0.1.0. Installers are unsigned; the macOS kit is not a built .pkg. Check downloads against checksums.txt.

Ghi v0.2.8

Testing and performance

• Run native Go benchmarks from Ghi tests with --bench, --benchtime, --benchmem and --count.
• Enable the Go race detector with ghi test --race on supported toolchains (requires CGO and a C compiler). Test watching forwards these options.
• Benchmark-only suites, repeated runs and source coverage work together; cancelled and failed runs preserve prior coverage files.
• Request Journal avoids an intermediate Go exception on missing-record reads. Measured results and limitations are documented in the README.
• The fresh-consumer service check now includes 16 concurrent clients, 480 CRUD lifecycles, shared-record history, cascading deletion, SQLite locks, disconnected writes and persistence after restart.

Distribution

Six portable archives for Windows, macOS and Linux (amd64/arm64), a Windows setup wizard and a macOS installer build kit. Bundled Mojave remains independently versioned v0.1.0. Verify downloads using checksums.txt.

The full compiler test suite and go vet passed on Windows amd64. Linux archive installation, automatic Go setup and execution are checked in containers; ARM64 uses emulation. Native macOS/Homebrew validation remains deferred. The macOS kit is not a prebuilt or verified .pkg. Installers are unsigned. GitHub Actions remains disabled.

Ghi v0.2.7

Ghi v0.2.7

Source coverage

• ghi test --cover reports executed Ghi statement entries by file and in total.
• --coverprofile coverage.out writes a Go-style mode: set profile with project-relative Ghi paths and byte columns; watch mode forwards coverage options.
• Constructors, methods, closures, exceptions and inherited method copies retain source identity. Uncalled production code remains in the denominator.
• Coverage counters exist only in test coverage builds. Failed or cancelled tests preserve the previous profile; protected input files cannot be overwritten.
• This measures statement entry, not branches or conditions.

Linux distributions

• Added Linux amd64 and arm64 archives alongside Windows and macOS.
• The archive installer verifies checksums with sha256sum or shasum, installs Ghi and independently versioned Mojave v0.1.0, and prepares a compatible Go toolchain.

Service integration

Request Journal now uses published arm092/config v0.1.0 together with migrations v0.4.0 and validation v0.1.0. Configuration is validated before opening the database; shutdown timeout is configurable.

Verification

• Windows amd64: complete go test ./... and go vet ./... passed.
• Linux amd64 and arm64: archive installation, automatic Go download, project creation/run and source coverage passed in Alpine containers. ARM64 used emulation, not native ARM hardware.
• Request Journal passed fresh Windows consumer checks and a Linux amd64 Docker deployment built from the public Ghi/Mojave release and locked packages: health, non-root read-only runtime, migrations, persistent data/history across container replacement, and completion of an active HTTP request after SIGTERM. The Docker recipe and smoke runner are available on master under services/request-journal.
• All six archives were checked for exact contents, embedded binary hashes and Unix executable permissions.
• Windows Setup and the macOS installer build kit are included. Native macOS/Homebrew checks remain deferred; there is no newly built macOS .pkg in this release. Windows ARM64 was cross-compiled, not run on native hardware.

Download an archive matching your OS and CPU, extract it completely and run its installer. checksums.txt covers the release assets. Go is prepared automatically when needed.

Ghi v0.2.6

Ghi v0.2.6

Faster checks and clearer diagnostics

• Reuse bounded copy buffers during dependency hashing, reducing allocation/GC work without skipping archive or extracted-source verification.
• Warm-cache Windows amd64 / Go 1.26.3 DDD checks measured 2.075 to 1.582 seconds unchanged and 2.096 to 1.665 seconds after an edit (seven samples after warm-up, alternating order). These are about 24% and 21% reductions in this run, not cross-platform guarantees.
• CLI compiler diagnostics include the original location/message, a source line, a caret and type mismatch details. Unsaved editor diagnostics via check --stdin retain their plain protocol.

Test watching

• Add ghi test --watch, with -run, -v and -timeout support.
• Watch production sources and root tests, debounce saves, serialize runs and rerun after edits during an active run.
• Keep watching after failures; cancel active process trees on exit. Reject invalid filters, timeouts and project paths at startup.

Real package integration

• Request Journal consumes published arm092/validation v0.1.0, alongside migrations v0.4.0.
• Validation returns field/code violations, aggregates semantic failures and preserves stored records and history when an update is rejected.
• The service's fresh-consumer workflow covers locked package installation, transactional tests, real HTTP CRUD, Unicode limits, concurrent writes, restart persistence and migration failure.

Distribution

Windows x64/ARM64 archives, Windows Setup, macOS Intel/Apple silicon archives and a macOS installer build kit are provided with SHA-256 checksums. Mojave remains independently versioned at v0.1.0. No prebuilt v0.2.6 macOS .pkg is supplied. Native macOS/Homebrew and Windows ARM64 execution remain unverified on this Windows host. No paid GitHub Actions were used.

Verification: full Go test suite and go vet passed on Windows amd64. All four archive contents and embedded checksums were verified. The packaged Windows amd64 CLI passed setup, init/run and the complete fresh Request Journal consumer workflow. Windows Setup was compiled; native installation was not rerun in this release. macOS build scripts passed shell syntax checks; no native macOS execution is claimed.

Ghi v0.2.5

Ghi v0.2.5

Development workflow

• Add ghi watch [--debug] [project] [-- arguments...]: content-based polling, debounced builds, and process replacement after successful compilation. Failed builds retain the running service.
• Track saves during compilation, including edit/revert sequences. Watch installed package sources and configuration while excluding generated caches and each source root's test directory.
• Cancel compiler subprocess trees and development services through Windows Job Objects or Unix process groups. Windows children start suspended until assigned to their job.

Compiler and diagnostics

• Reuse validated namespace bodies after edits, checking affected consumers and inheritance components. Dependency, toolchain, manifest and class-graph changes invalidate the relevant cached certificates.
• Fix compound assignment and increment/decrement on generic numeric fields, including inherited fields.
• Prevent generated forwarding parameter names from capturing generic or concrete type names.
• Preserve source positions and imported aliases in constructor, inheritance and override diagnostics, including multiline have/want messages.
• Prepare staged Go modules without two redundant Go commands. Verify downloaded archives and extracted contents against locked checksums with bounded parallel hashing on every compilation; corruption still rejects output.

The final warm-cache Windows DDD check comparison measured 1.714 → 1.773 seconds unchanged and 1.788 → 1.849 seconds after an edit. The complete pipeline, which also adds subprocess-tree cancellation, was about 3% slower in this run. No overall compilation speedup is claimed. See the README and raw samples for details.

Standalone service and IDE

• Add services/request-journal, an independent HTTP backend using chi, SQLite, string-backed status enums and the published migration package. It includes CRUD, pagination/filtering, transactional status history, validation, startup migrations and shutdown handling.
• Verify a fresh consumer using published Ghi v0.2.4, Mojave v0.1.0 and migrations v0.4.0, before this release. Tests cover real HTTP, concurrent writes, process restart persistence, migration failures and database connection replacement after cancellation.
• GoLand Plugin v0.1.3 is available separately on GitHub. Its owner verified multiline diagnostics, source coordinates, imported aliases and editor overlays, with 66 passing tests and Plugin Verifier compatibility on 251 and 262.

Downloads and verification

• Windows x64/ARM64 archives and a native Setup executable.
• macOS Intel/Apple silicon archives and a universal installer build kit. Build the .pkg on a Mac with Apple Command Line Tools; no prebuilt v0.2.5 .pkg is supplied.
• Homebrew formula updated after publication to the verified source archive checksum.
• Mojave remains independently versioned at v0.1.0.
• SHA-256 checksums accompany all archives, Setup and the installer kit.

The full Go suite, go vet, targeted process-tree/watch regressions, standalone-service tests and the packaged Windows amd64 smoke checks passed. Native macOS/Homebrew and Windows ARM64 execution were not performed on this Windows host. No paid GitHub Actions were used.

Ghi v0.2.4

Ghi v0.2.4

Compiler and build performance

• Specialize small inherited methods across namespaces and generic hierarchies, including concrete descendants of generic bases and nested type arguments.
• Preserve virtual dispatch, parent, receiver aliases, closures, visibility and original exception source locations. Generated type aliases avoid capturing user-local names.
• Reuse validated generated Go output in .ghi/build, with content-based invalidation for sources, installed Ghi packages, manifests, lockfiles, compiler/toolchain settings and Go export artifacts.
• Retain stable generated paths so Go can reuse unaffected packages; reuse previous output as an atomic build candidate so Go can skip unnecessary linking.
• Overlap dependency checksum verification with Ghi analysis. Verification must succeed before generated output is accepted; failures preserve the previous executable.
• Keep debug/test/editor-overlay workspaces isolated. Busy or unavailable caches fall back to temporary compilation.
• Improve missing-record handling in the DDD example without constructing an intermediate native exception.

Measurements

Windows amd64, Core i9-13900HX, Go 1.26.3; local medians, not cross-platform guarantees:

Workload	Before	After
Generic inheritance, concrete descendant	3.838 ns/op	1.140 ns/op
Generic inheritance, generic descendant	4.243 ns/op	1.057 ns/op
DDD build, unchanged sources	3.987 s	2.095 s
DDD build, one edited service	3.822 s	2.934 s

Generic call fixtures allocate zero bytes per operation. Ghi still performs project-wide semantic checking after source edits. Methods that rebind/address this, oversized bodies and inaccessible declarations retain shared implementations. Debug builds disable receiver specialization. See the English README and raw benchmark samples for methodology and limitations.

Downloads

• Windows: native x64/ARM64 Setup, or portable archives.
• macOS: Intel and Apple silicon portable archives, or Homebrew using the updated repository formula. The installer kit builds an unsigned universal .pkg on a Mac with Xcode Command Line Tools; a native v0.2.4 .pkg is not supplied.
• Mojave remains independently versioned at v0.1.0.
• SHA-256 checksums accompany the archives, installer and macOS installer kit.

Verification

The complete Go test suite and go vet passed. The packaged Windows amd64 CLI passed version/setup, project initialization, repeated execution and DDD unit/integration tests. All eight bundled binaries have verified target architectures, and archive contents/checksums were verified. Native Windows ARM64, macOS installation and Homebrew runtime checks were not performed on this Windows host. The Windows installer was compiled successfully; native macOS/Homebrew verification remains deferred. No paid GitHub Actions were used.

Ghi v0.2.3

Ghi v0.2.3

This release focuses on runtime and build performance. Mojave remains independently versioned at v0.1.0.

Faster classes and exceptions

• Specialize concrete receivers for leaf classes and small inherited methods within the same namespace, while preserving virtual dispatch, parent, aliases and source locations. Debug builds retain their original receiver representation.
• Cache bounded, immutable stack descriptions while giving each exception its own mutable frames. Capture cacheable stacks in one traversal and allocate frame objects together.
• Preserve complete deep stacks, original traces on rethrow and user-supplied traces. Exceptions still capture their throw location immediately.
• In local Windows/Go 1.26.3 microbenchmarks, the 96-recursion exception fixture decreased from about 22.2 to 5.12 microseconds after the combined changes. These warmed measurements do not predict first-throw latency or all applications.

Faster builds

• Load external Go export metadata in one request instead of repeated go list calls. Dependency integrity checks and compiler validation remain enabled.
• On the DDD example, an unchanged build decreased from 6.66 to 4.05 seconds. A separate empty-Go-cache observation decreased from 40.68 to 16.53 seconds. Results depend on the machine and cache state.

Application measurements

Added a reproducible localhost HTTP/SQLite comparison using the real Ghi DDD server and a Go counterpart for the measured users routes. All 720,000 measured responses passed status and byte-for-byte JSON validation. List throughput was similar; successful single-user reads were about 3–8% lower for Ghi in this setup. Single-client not-found requests were about 13% lower, with Ghi capturing exception stacks and Go returning ordinary errors. The benchmark uses one SQLite connection and is not a production capacity estimate.

See the README performance section for source, raw samples and limitations.

Downloads and verification

• Portable archives: Windows x64/ARM64 and macOS Intel/Apple silicon, each bundling Ghi and Mojave with checksums, installers and license notices.
• Windows setup executable with its SHA-256 sidecar.
• Homebrew formula updated to the release source archive.
• Full compiler/language/CLI/toolchain/debugger tests, benchmark correctness checks, release-binary project creation/execution and DDD tests were run on Windows amd64.
• macOS binaries are cross-compiled. Native macOS/Homebrew checks remain deferred; no new .pkg is included. The installer is unsigned. Windows ARM64 execution was not verified on native hardware.

Ghi v0.2.2

Ghi v0.2.2

Language

• Plain enums declare distinct types, for example enum Direction { North, South } with Direction.North values.
• Enums with explicit values require a string, int or bool backing type. Their cases are immutable primitive constants and can be passed directly to parameters of that type.
• Enum case imports, aliases, default arguments, generic comparable constraints and canonical formatting are supported. Plain enum construction/conversion and case mutation are rejected.
• The English README includes the full enum syntax and rules, with a runnable examples/enums project. Existing match semantics remain unchanged.

Editor integration

ghi check --stdin --filename /absolute/project/main.ghi /absolute/project checks an unsaved editor buffer without changing its existing production source file. Diagnostics refer to the original source path and positions. Other project files and dependencies are loaded normally. This is supported by Ghi for GoLand v0.1.1.

Installation and versions

Download a Windows setup wizard or a portable archive for Windows/macOS, Intel/AMD64 or ARM64. Bundled Mojave remains independently versioned at v0.1.0. Ghi for GoLand v0.1.1 is available in its own GitHub repository.

Native macOS v0.2.2 execution and Homebrew verification are deferred. No v0.2.2 .pkg is published; the previous v0.2.1 .pkg does not include these features. Installers are unsigned. GitHub Actions was not used.

Verification

The full compiler/language/toolchain/CLI suite and go vet passed during implementation after fixing nullable parsing integration. Final enum tests cover original diagnostics, imports, shadowing, primitive calls, JSON, immutability, conversion rejection and formatter idempotence. Existing DDD integration/unit tests and the runnable enum and README examples passed. Release CLI tests passed after the version update. All four portable archives and their embedded executable checksums were verified. The packaged Windows compiler reports v0.2.2, runs the enum example, and returns the original-file diagnostic for an unsaved enum mutation without changing disk. The Windows installer passed install/reinstall, both compiler examples, independent Mojave version, uninstall and exact PATH restoration checks.

Language documentation · GoLand v0.1.1 · Mojave v0.1.0