Geno 0.5.0

Geno 0.5.0

Geno 0.5 adds module-level constants and executable exit statuses, and improves
type checking, backend consistency, formatting, and hosted operation. This is
the non-prerelease promotion of the frozen RC.1 feature set. Geno remains a
preview project with its existing pre-1.0 compatibility policy.

Install explicitly with Python 3.10–3.13:

python -m pip install --upgrade "geno-lang==0.5.0"

Highlights

• Module-level let constants can hold literal values, lists, and tuples.
  They are private to the module and do not execute code during import.
• Constructors accept named arguments, with consistent validation and
  source-order argument evaluation across backends.
• An Async value executes at most once, and repeated awaits observe the same
  result or error. Nested record writes preserve the value of aliased siblings.
• Python Float promotion, JavaScript value display, pipeline postfix parsing,
  generic match arms, and path builtins behave more consistently.
• Formatting preserves block and bracket structure and checks its result
  before writing. The REPL retains printed output and reports useful positions.
• Hosted readiness checks exercise workers; shutdown drains active work.
• Example comparison now treats integers exactly and uses consistent relative
  Float tolerances through nested values and all harness paths.
• geno run --json preserves very large integers as exact numeric tokens,
  including values inside collections. Python's global integer conversion
  safety limit and the server's response-size limits remain unchanged.
• Target validation loads only the selected compiler backend. Existing
  performance budgets and all backend-lowering checks remain in force.

Breaking changes and migration

main() -> Int now selects the process exit status, normalized modulo 256.
return 2 exits 2; return 258 exits 2; return 0 - 1 exits 255. The integer
is no longer printed as => N. The CLI, standalone Python, Node scripts and
directly executed Node ESM follow the same rule. Output printed before return
is preserved. A normal nonzero exit carries no traceback or diagnostic.

To display a computed integer, print it and return Unit:

func main() -> Unit
    print(42)
    return ()
end func

geno run --json retains the raw result in value, while its process exits
with the normalized status. Shell scripts using set -e and callers using
check=True must allow a valid JSON result with a nonzero exit. JSON mode grants
no capabilities by default; explicitly pass --cap print for printed output.

Embedding via geno.run() still returns the raw result without terminating
its caller. Grant embedding print access with RunConfig(capabilities={"print"}). Importing generated Python or Node ESM remains inert. Browser
artifacts retain display behavior because they have no process exit status.

Checks now reject parameterized entrypoints, ambiguous bare imports, repeated
type or constructor definitions, reuse of builtin type names, and duplicate
methods in an impl. Diagnostics identify the definitions or qualified imports
to use. Async computations no longer repeat on subsequent awaits.

Consumers reading large JSON integers must preserve their required precision;
Python callers can use json.loads(text, parse_int=decimal.Decimal).

See proposal 0001
and the 0.5 specification.
Stable promotion is authorized by accepted proposal 0002.
David Iach waived the waiting periods and external human review for this
promotion only, conditional on all technical checks passing. No external human
approval or completed observation period is claimed.

Known limitations

• Package management, editor tooling, the formatter, and selfhost remain
  experimental. Selfhost has no code-generation or bootstrap path.
• Default isolated geno run does not accept explicit --cap; use the
  documented execution mode appropriate to the workload. Alternate named
  entrypoint selection remains unavailable.
• JSON mode is an in-process embedding path with cooperative limits.
  Generated JavaScript is intended for trusted execution environments.

Support and rollback

David Iach is the release and incident/support owner. Report bugs through the
issue tracker. Report security
vulnerabilities privately through GitHub vulnerability reporting,
following the security policy.
Rollback uses a revert or forward fix and a newly versioned, fully gated release;
published tags and artifacts remain immutable.

Validation

Source: 92ca21627715313600a77ba5127833960ca315b0.

• Final canonical local release gate: 7,411 passed, 13 conditional skips,
  83.54% coverage; all 130 retained conformance cases passed with Node required.
• make security: 488 passed, three Windows-only skips on macOS;
  the separate bounty corpus blocked 146/146 attacks with no escapes.
• Runtime, development, and release-tool dependency audits passed. The Linux
  release lock was audited in hosted CI; its documented macOS skip is retained.
• Final main CI
  and Release Gate
  passed on the exact source commit, including Python 3.10–3.13 and supported OS checks.
• Final Scheduled Quality
  passed deep differential fuzzing and all six existing performance budgets.
• Published RC.1 wheel/sdist checks passed, including exit/output/JSON/embedding/import
  behavior and runbook smokes. The RC wheel passed all 101 corpus applications
  and six sitecheck cases at pinned source commits. Promotion changes only
  version metadata and release documentation/policy.

Publishing workflow
passed its canonical release gate (7,412 passed, 12 conditional skips,
83.61% coverage on Linux), built the distributions once with locked tools,
passed strict Twine and fresh wheel/sdist smokes, published those same bytes to
PyPI, and passed its public-install verification.

Independent fresh downloads from PyPI matched the workflow artifacts byte for
byte. Both wheel and sdist passed official install smokes, exit/output/JSON/API
checks, Fibonacci, and all 78 benchmark problems. The published wheel also
passed 101/101 corpus applications and 6/6 exact sitecheck cases. Both
artifacts' 96 production code files and all 99 wheel package assets differ from
RC.1 only by the expected version string.

The release assets include those exact workflow distributions, a SHA-256
manifest, and an evidence archive with commands, environments, pinned sources,
migration patch, results, and logs. Its portable installed/runbook/comparison
drivers were executed directly; the complete reproduction wrapper has only
received syntax and argument-help checks. No locally rebuilt distributions are
attached.

Geno 0.5.0-rc.1

Geno 0.5.0-rc.1

Geno 0.5 adds module-level constants and executable exit statuses, and improves
type checking, backend consistency, formatting, and hosted operation. This is
a prerelease for evaluation; Geno remains a preview project.

Install explicitly with Python 3.10–3.13:

python -m pip install --upgrade "geno-lang==0.5.0rc1"

Highlights

• Module-level let constants can hold literal values, lists, and tuples.
  They are private to the module and do not execute code during import.
• Constructors accept named arguments, with consistent validation and
  source-order argument evaluation across backends.
• An Async value executes at most once, and repeated awaits observe the same
  result or error. Nested record writes preserve the value of aliased siblings.
• Python Float promotion, JavaScript value display, pipeline postfix parsing,
  generic match arms, and path builtins behave more consistently.
• Formatting preserves block and bracket structure and checks its result
  before writing. The REPL retains printed output and reports useful positions.
• Hosted readiness checks exercise workers; shutdown drains active work.
• Example comparison now treats integers exactly and uses consistent relative
  Float tolerances through nested values and all harness paths.
• geno run --json preserves very large integers as exact numeric tokens,
  including values inside collections. Python's global integer conversion
  safety limit and the server's response-size limits remain unchanged.
• Target validation loads only the selected compiler backend. Existing
  performance budgets and all backend-lowering checks remain in force.

Breaking changes and migration

main() -> Int now selects the process exit status, normalized modulo 256.
return 2 exits 2; return 258 exits 2; return 0 - 1 exits 255. The integer
is no longer printed as => N. The CLI, standalone Python, Node scripts and
directly executed Node ESM follow the same rule. Output printed before return
is preserved. A normal nonzero exit carries no traceback or diagnostic.

To display a computed integer, print it and return Unit:

func main() -> Unit
    print(42)
    return ()
end func

geno run --json retains the raw result in value, while its process exits
with the normalized status. Shell scripts using set -e and callers using
check=True must allow a valid JSON result with a nonzero exit. JSON mode grants
no capabilities by default; explicitly pass --cap print for printed output.

Embedding via geno.run() still returns the raw result without terminating
its caller. Importing generated Python or Node ESM remains inert. Browser
artifacts retain display behavior because they have no process exit status.

Checks now reject parameterized entrypoints, ambiguous bare imports, repeated
type or constructor definitions, reuse of builtin type names, and duplicate
methods in an impl. Diagnostics identify the definitions or qualified imports
to use. Async computations no longer repeat on subsequent awaits.

Consumers reading large JSON integers must preserve their required precision;
Python callers can use json.loads(text, parse_int=decimal.Decimal).

See proposal 0001
and the 0.5 specification.
The accepted rollout permits this change as a 0.5 prerelease; stable publication
requires a separate proposal.

Known limitations

• Package management, editor tooling, the formatter, and selfhost remain
  experimental. Selfhost has no code-generation or bootstrap path.
• Default isolated geno run does not accept explicit --cap; use the
  documented execution mode appropriate to the workload. Alternate named
  entrypoint selection remains unavailable.
• JSON mode is an in-process embedding path with cooperative limits.
  Generated JavaScript is intended for trusted execution environments.

Validation

The exact release tree passed all 19 local release stages: 7,412 tests passed,
12 expected conditional skips, and 83.61% coverage. All 130 conformance cases
passed, all 146 security attacks were blocked, and all six existing performance
budgets passed. Fresh wheel and source installs passed executable, embedding,
capability, and large-integer JSON checks. External validation passed all 101
corpus applications and six migrated sitecheck cases.

The final review finding was fixed and covered by regression tests; repeated
Codex advisory review reported no actionable regressions. The full hosted
Python/OS matrix and deep differential fuzzing passed.

• Integrated-commit CI
• Performance and deep fuzzing
• Release gate, artifact checks, PyPI publication and verification

Release commit: e0606a6aea1d8da63b539a7eacc47bf49d4f0654.

Fresh installation from PyPI passed the official smoke test, 24 executable
exit/output checks, embedding and capability checks, exact large-integer JSON,
and the post-release benchmark check. Both attached distributions match PyPI's
SHA-256 hashes; see the attached checksum manifest.

Geno v0.4.4

Geno 0.4.4 improves backend consistency, browser apps, diagnostics, and hosted execution security. Geno remains a preview release for early evaluation.

Install or upgrade with Python 3.10–3.13:

python -m pip install --upgrade "geno-lang==0.4.4"

Highlights

• More consistent execution: fixes Python block scoping, JavaScript same-block rebinding, named-argument evaluation order, captured mutable bindings, and numeric widening. Entrypoint results now use Geno formatting consistently, including booleans, strings, and non-finite floats. Runtime NameError failures are no longer silently swallowed.
• Language improvements: tuple patterns work in match, sum types accept a leading |, and zero-argument examples accept example -> value. Synchronous main functions containing await now lower correctly on both compiled backends and the isolated CLI.
• Browser apps: single-file and directory builds share responsive canvas setup, preserve small canvases at their intended size, map pointer coordinates after scaling, and reset controls after focus or visibility loss. Builds create missing output directories.
• Better authoring feedback: missing imports, named arguments, examples, and examples rejected by preconditions receive actionable diagnostics. Import suggestions respect aliases and exports. Package-lock setup failures produce a diagnostic instead of a traceback.
• Tooling and startup: improves deep import resolution and editor cache refreshes, preserves multiline strings in the formatter, completes nested REPL definitions, and reports language-server launch failures. Isolated geno run avoids duplicate frontend imports; measured startup improvements are about 15% for the hello scenario and 7% for the medium scenario.

Compatibility and migration

The release owner approved one deliberate exception to the patch compatibility policy. In target-less programs whose entry module defines main, geno check, geno test, and editor diagnostics now validate Python lowering, matching the default geno run. A program that previously passed checking can now fail earlier if it uses a Python-backend reserved name. Those programs already failed the default run path; this change moves the diagnostic earlier.

Rename the identifier named by the diagnostic. For example, replace the parameter len and its uses with count:

func widen(count: Int) -> Int
    example 2 -> 4
    return count * 2
end func

func main() -> Int
    return widen(2)
end func

Library modules without main remain exempt. The geno.check() embedding API remains permissive unless a target is selected explicitly. The frozen v0.4 conformance corpus is retained.

Embedders should configure each interpreter's collection limit through SandboxConfig.max_collection_size. The process-wide geno.builtins.set_max_collection_size setter now controls direct module-level builtin calls only.

Building or packaging the VS Code extension requires Node.js 22–24. The supported VS Code API remains compatible with VS Code 1.91.

The release includes result-classification groundwork for proposal 0001. It does not activate the proposal's integer-return exit-status behavior: returning an integer from main still displays that value rather than selecting the process exit status.

Security fixes

• Standalone Python and JavaScript capability parsers stop at --, preventing forwarded program arguments after that delimiter from granting capabilities.
• Hosted request headers have a separate five-second default read budget, configurable with GENO_HEADER_TIMEOUT_SECONDS. Refused connections are counted and logged.
• Hosted workers bound response bodies before IPC; oversized /run and /constrain results return HTTP 413. Malformed Unicode inputs and out-of-range timeouts return HTTP 400.
• Updates include cryptography and the extension's transitive js-yaml, qs, and undici dependencies.

Known limitation

Float example comparisons still differ between the interpreter and the separate source/compiled harnesses. A rounded expectation can pass one path and fail another, particularly at larger magnitudes. Preserve the full printed value instead of rounding to a fixed number of significant digits. Comparator alignment is tracked in #111.

Release evidence

Release commit: b9aef4af8baf5e581a7f9c65afd904e956b7aae2.

• Main CI: passed.
• Hosted release gate: passed.
• Real Chrome smoke: five desktop/narrow viewport cases, pointer scaling, and input recovery after actual tab switching passed with no JavaScript errors.
• Local release gate: all 19 stages passed; 6,582 tests passed, 29 skipped, with 83.02% coverage.
• Publishing workflow: the Linux release gate, wheel/sdist build and smoke tests, PyPI upload, and PyPI installation verification all passed.
• Independent PyPI installation smoke passed for runtime assets, standard-library JavaScript compilation, CLI checks, embedding, and capability/host-callback behavior. Published wheel and source-archive hashes match the workflow's tested artifacts.

See the full changelog and changes since v0.4.3.

Geno v0.4.3

Changed

• Toolchain and supply-chain maintenance: Updated Ruff, pinned GitHub Actions, the PyPI publishing action, and VS Code extension transitive dependencies.
• Release validation: Release tags must now point to main and be newer than existing changelog and repository releases, with dated, non-empty release notes.

Fixed

• Direct Unit results: geno run --unsafe now keeps main() -> Unit silent, matching process-sandboxed and standalone execution.

Geno 0.4.2 — Public Preview

Geno 0.4.2 strengthens the Geno public preview while preserving the released v0.4 result contract.

Highlights

• Publishes the normative v0.4 language contract, compatibility policy, proposal process, stable diagnostic ownership, and frozen interpreter/Python/JavaScript conformance corpus.
• Repairs compiled Node HTTP, including bounded streaming, redirect and private-address policy, duplicate headers, non-2xx bodies, and CommonJS/ES-module parity.
• Aligns target-aware checks with compilation and adds explicit execution-profile selection without changing compile --target python|js.
• Adds capability-gated filesystem metadata, symlink metadata, and canonicalization with compiled Python/Node parity.
• Adds whole-document LSP formatting and strengthens release qualification with scheduled differential fuzzing and all-backend checks.
• Preserves v0.4 compatibility: main() -> Int remains an ordinary displayed result with successful status in primary geno run and standalone artifacts; embedding returns the value, generated imports stay inert, and uncaught runtime faults remain nonzero with diagnostics.

Portable integer process-exit semantics remain a future versioned language proposal and are not enabled in the 0.4.x line.

Install

pip install geno-lang==0.4.2
geno --version

The release was validated across Python 3.10-3.13, macOS, Windows, the interpreter and compiled Python/JavaScript backends, security and sandbox regression gates, dependency audits, wheel/sdist smoke tests, and a clean install back from PyPI.

See the full changelog and the PyPI package.

Geno 0.4.1 — Public Preview

Geno 0.4.1 is a security and reliability update for the Geno public preview.

Highlights

• Hardens untrusted process execution on POSIX and Windows, including worker startup, supervision, cleanup, resource enforcement, compiled-runtime prelude handling, and regex limits.
• Strengthens package integrity through safer source capture, lock/state handling, symlink validation, crash recovery, content hashing, and release dependency verification.
• Tightens hosted execution boundaries for Host and forwarded headers, request bodies, module loading, and deployment health checks.
• Packages the Python language-server runtime in the VS Code extension and resolves known extension dependency vulnerabilities.
• Stabilizes macOS sandbox memory enforcement with a finite Darwin growth budget and an XNU-compatible runtime boundary probe.

Install

pip install geno-lang==0.4.1
geno --version

The release was validated across Python 3.10-3.13, macOS, Windows, compiled JavaScript, security and sandbox regression gates, dependency audits, wheel/sdist smoke tests, and a clean install back from PyPI.

See the full changelog and the PyPI package.

Geno 0.4.0 — Public Preview

Geno 0.4.0 is the first public preview of Geno, a statically typed, functional-first language that compiles to Python and JavaScript.

Highlights

• Aligns interpreter, Python, and JavaScript semantics for numeric equality, division, output formatting, map ordering, value copying, and integer safety.
• Fixes type-soundness gaps in named arguments, mutable generics, and effect propagation.
• Hardens parsing, diagnostics, sandbox behavior, regex/JSON limits, capabilities, and runtime helper ownership.
• Adds dedicated cross-backend parity and release-regression suites.
• Polishes public documentation, package metadata, install instructions, release automation, and VS Code packaging.

Install

pip install geno-lang==0.4.0
geno --version

The release was validated across Python 3.10–3.13, macOS, Windows, compiled JavaScript, security gates, wheel/sdist smoke tests, and a clean install back from PyPI.

See the full changelog and the PyPI package.