v1.13.0 is the largest range let-go has shipped, 179 PRs since v1.12.2, and much of it came from running real Clojure libraries and watching where they broke.

Many thanks to @mparrett @nnunley and @abogoyavlensky 🤝

Two first-time contributors landed their first PRs! @dharmatech fixed Plan 9 key reads hanging on terminal resize. @jasalt added a CompilerContext accessor so a host nREPL server shares the application's live compiler state, and fixed test/run-tests throwing when it restored the namespace. Thank you!

Breaking: The opcode set changed (a new unchecked-arithmetic trio) and compressed bundles moved to format version 3, so an older lg won't load .lgb files built by this release. Rebuild your bundles.

See Bundle format and compatibility breaks below before you upgrade anything that ships .lgb files.

---

Language and compatibility

Real-world Clojure libraries drove most of this: integrant, ragtime, clojure.test.check, and clojure.data.priority-map each exposed a specific gap.

• clojure.test, ported for real. Report, assert, fixture, and runner contract replace the partial namespace that shipped before. #863
• [x & more] now binds nil, not (). The old behavior made a destructured empty rest arg truthy, which hung weavejester/dependency's reachability loop, and any (if-let [[x & xs] s] ...) pattern, on a three-element chain. #898
• Thread/currentThread and format's %n. Thread/currentThread resolves to the calling scope dressed as a java.lang.Thread, so .isInterrupted means "was my scope cancelled," and the cooperative-cancellation idiom ragtime uses compiles. format honors Java's %n instead of erroring. #901
• *unchecked-math* is live. +, -, *, inc, and dec rewrite to their wrapping forms under the binding instead of being silently ignored. #839
• Math/* and friends. Long/bitCount, Integer/MAX_VALUE, Double/NaN, and the rest are pinned to JVM semantics rather than Go's. Java rounds -2.5 to -2; Go doesn't. #840
• Canonical (. obj member ...) interop forms compile, not just .member sugar. #841
• Custom data readers via a dynamic *data-readers*, honored by read-string, load-string, ordinary compilation, and child eval contexts. #770
• clojure.edn/read-string reads data, not code. ^{:a 1} x attaches metadata instead of yielding (with-meta ...), #{} reads as a set, interior #_ no longer errors on an odd map, and duplicate keys are rejected. #854
• clojure.string/split follows Pattern.split. Trailing empty fields are dropped, it returns vectors instead of lists, and it takes a limit arity now. split-lines was added too. #843
• Small maps preserve insertion order, matching Clojure's array-map semantics. #764
• reify accepts Object overrides: toString, hashCode, equals. #762
• Symbols are invokable for collection lookup, as keywords already were. #758
• Multi-arity dispatch fix. An exactly-min-arg call now routes to the variadic variant, and an empty kwargs rest stays nil through map destructuring instead of {}. #760
• var special form reaches private vars across namespaces; bare qualified-symbol references stay privacy-enforcing. #756
• json/write-json writes string map keys as text, not as their EDN reading. {"key" "value"} no longer emits {"\"key\"":"value"}. #820
• line-seq surfaces read errors instead of silently ending the sequence. #855
• test/run-tests restores the caller's namespace after an explicit-namespace run, instead of throwing. #798
• JVM string/keyword interop surface plus a StringBuilder shim, needed for clojure.data.priority-map and similar libraries. #787
• Interop boundary fixes: collections cross the Go/let-go boundary as native values, the reflect proxy boxes a multi-return func as a vector, and typed-array backing slices survive interop. #778, #776, #821
• clojure.repl and clojure.pprint land with a Var-metadata bundle round trip. #668
• clojure.data gets structural projection. #711
• thrown?, thrown-with-msg?, run-test-var, and run-test fill out the pre-#863 test surface. #754, #671
• A known-divergences catalog tracks what Clojure behavior let-go still doesn't match, narrowed for array-map this cycle. #771, #826

Also: warn-on-core-shadow now fires for compiled defs (#734), tab completion no longer crashes on a cyclic refer graph (#710, #713), *out*/*err* defer to the current stdout/stderr rather than the boot-time handles (#611).

Concurrency and networking

The HTTP namespace gained a handle you can hold instead of a bare ListenAndServe call, motivated by a real integrant and SQLite web app, and an nREPL hub carrying a downstream patch.

• http/start, http/stop, http/wait. serve is now start plus wait, and a bad bind address throws at bind time instead of from inside the request loop. #898
• Streaming response bodies. A channel or lazy-seq response body is written element by element with a flush after each, which enables SSE and long-polling handlers. #851
• Three named timeout scopes on http/request: connect, request, and stream_read, each naming itself in the resulting error. #856
• HTTP clients inherit the caller's scope cancellation. Closing a scope now aborts an in-flight http/get, http/post, or http/request call, including one blocked reading a :as :stream body. Before this, the request and its goroutine outlived the scope. #848
• net/listen, net/accept, net/local-address give TCP the owned-listener surface unix already had. #896
• scope-cancelled? lets code distinguish "woke up" from "was cancelled" after a blocking native call returns. #850
• eval runs in the caller's execution context, so binding and with-out-str reach the evaluated form. This is what an in-editor REPL needs to capture what a form prints, not only what it returns. #853
• bound-fn* conveys the binding stack correctly. An earlier fix rebuilt a bound call's context from a captured snapshot alone, which silently reverted any dynamic var the caller had bound but hadn't captured. The clojure.test port replaced that mechanism with an overlay onto a child of the caller's context, matching Clojure's push-thread-bindings, while keeping the original fix's guarantee. #852, superseded by #863
• HTTP clients now accept an empty :headers map without erroring. #849 / #898

Runtime correctness: 64-bit ints everywhere

A let-go program now computes the same values regardless of host width.

• Int is 64 bits wide on every platform, not type Int int following the platform word size. On linux/386, linux/arm, and TinyGo wasm, (bit-shift-left 1 40) used to return 0 and (* 1e9 1e9) trapped. The guarantee covers the VM's arithmetic core. Collection indexing, clojure.math's *-exact family, range bounds, and ToInt still convert through the platform int and can wrap above MaxInt32 on a 32-bit host. #859
• 64-bit integers now survive the pkg/rt boundary on 32-bit hosts. Math/abs, hash, parse-long, and the *-exact family return full-width values instead of silently wrapping. The pkg/vm half of the same class of bug, collection indexing, range, get, is unfixed. #906
• The AOT lowerer types :int as Go int64, which is also what makes lowered trees compile under TinyGo. #862
• xxh3 reaches TinyGo wasm for the first time, via Wrap-based adapters where the reflect-boxed generated binding couldn't go. Combined with the width fix above, a hash chain now produces byte-identical output on a TinyGo wasm build and on native amd64. #860
• Plan 9 key reads wake on terminal resize instead of hanging. #743
• WASM key input became an SPSC ring with held-key coalesce, replacing single-slot drop semantics. A synchronous burst of 10 keys went from 1 accepted and 9 dropped to 7 or 8 accepted, measured against the xsofy shell. Hosts that assumed single-slot semantics should revalidate interactive input paths. #595
• The TinyGo gate moved to wasmtime 0.42.0, with the asset fetched from a pinned release instead of curl | bash. #909, #877

Also: SameFile stubbed for js/wasm in pkg/bundle (#629), wasm_exec.js resolved from the active Go toolchain instead of a hardcoded path (#837).

AOT and native compilation

• AOT lowering no longer needs a source checkout. The driver is now the embedded lg.compiler namespace, so a shipped lg binary drives lowering from any directory. scripts/lg-compile keeps its path, argv, and exit codes as a thin shim over it. #735
• --entry-frame emits a native-entry Go frame from main or -main, and no longer runs it twice. lg -c now omits only the selected entry call when it builds the bundle, so the fact that it's an entry point lives in the artifact instead of a global *compiling-aot* flag that would also skip every other namespace's runtime init. #628, fixed by #902
• unchecked-add, unchecked-subtract, unchecked-multiply are first-class IR and VM ops, so a hash or PRNG inner loop keeps its typed native path instead of boxing every step. This is also one half of the bundle-compatibility break below. #811
• Direct bytecode calls no longer recurse through Go's native call stack. An explicit frame chain replaces it, so deep non-tail let-go recursion no longer risks a Go stack overflow. #645
• Self-recursive calls seed their return type from a declared annotation (#662), and function-level recur gets its own OP_RECUR_FN op instead of piggybacking on a different lowering path (#642).

Bundle format and compatibility breaks

Two independent, intentional breaks ship in this release. Both cause an older runtime to reject a bundle outright. That's by design, not corruption, but it isn't obvious from the error alone.

1. The opcode set changed. #811 appends OP_UNCHECKED_ADD, OP_UNCHECKED_SUB, and OP_UNCHECKED_MUL. A .lgb built by an older lg is rejected by this one, the same trade an earlier release made when it added OP_DIV. Rejection errors now name the missing capability instead of printing a bare mask. #608, #622
2. Compressed bundles are format version 3. Magic, version, flags, and the capability payload stay plaintext so compatibility checks run before decompression, but an older decoder rejects a version-3 bundle as an unsupported version, and version 2 now rejects the compression flag at the header. Uncompressed bundles are unaffected and stay version 2. The committed core bundle stays uncompressed by default, so this only reaches someone who opts in with lg -c -z or lg -b -z. #501, #502

Related bundle work:

• lg -strip splits debug info into a digest-bound .lgb.debug companion instead of discarding it. A mismatched companion is rejected instead of producing misleading tracebacks, and it now composes with -w bundles too. #624, #800
• The bundle encoder no longer aliases function chunks by scanning for identical bytecode. Two structurally identical functions could previously swap source metadata. #745
• lg_no_http build tag drops net/http from the runtime entirely. #658
• The embedded core bundle shrank from 311,302 to 273,748 bytes after ir.data stopped being compiled into the shared const pool. #838

Go API and build-layout changes:

• 34 exported per-file core-embed symbols removed (rt.SetSrc, rt.TestSrc, and so on), superseded by coreFS. No public callers were found at review time. #604
• The CLI moved out of the root package into pkg/cli. Root package went from eight Go files to three. Anyone importing root-package symbols moves to pkg/cli, see docs/guide/custom-lg.md. This is also what makes the interop packages self-contained enough for a third-party module to build its own lg-equivalent binary. #773
• api.LetGo exposes CompilerContext(), so a host nREPL server, or a similar integration, can share the running application's live compiler state instead of constructing a disconnected second one. #803
• Build outputs moved into build/, and lg is promoted into bin/. Scripts hard-coding the old paths need updating. #733
• Go toolchain floor is now single-sourced from go.mod, initially pinned to 1.26.5 (#677) and then bumped to Go 1.27, with golangci-lint pinned alongside it (#910). The manifest generator now reads the toolchain from go.mod rather than GOTOOLCHAIN=local (#916).

Performance

No headline benchmark numbers ship with this release. The measurement tooling itself, bench-ratchet, needed fixing more than the runtime did for most of this range: a stale probe table produced apparent regressions that turned out to be a baseline-selection bug, not a real one. Read this section as "the direction is good," not "here is the number."

reduce's ArrayVector and Range fast paths were restored after a registrar shadowed them (#686). PreparedCall for per-element callback loops landed in some (#726) and in reduce's four fold loops (#727), then made allocation-free (#794); a reduce benchmark measured 50.5ms against 58.7ms on v1.12.2, below the old baseline rather than merely recovered toward it, though that number predates the pinned-SHA audit this project still owes itself. Cold error arms moved out of the dispatch loop (#723), the runLoop hop was removed (#730), and defer scaffolding stayed off the hot path (#719). Catalog-driven op and form-head dispatch (#612, #667), direct-call natives for the hot clojure.core surface (#613), and 222 primitives hoisted to //lg:native declarations with a per-package registrar (#639, #640). Ordinary var loads are re-emitted rather than copied (#579), and lazy var metadata was compacted (#781).

The other half of this release's perf story is the measurement infrastructure: deterministic forced rebaselining and a pre-push gate (#780), the baseline reseeded from a measurement window instead of a single point (#684), a per-release baseline frozen on every tag (#740), a machine-quiescence lease so benchmark runs don't compete with other jobs for CPU (#795), and the deterministic-metrics judge fixed to compare against the newest-provenance entry per metric instead of a global minimum across differently-aged profiles, which is what had been producing phantom 60 to 70 percent regression reports. #900

Also: per-iteration setup hoisted out of vector benchmark loops (#882), execution-entry modes distinguished in compiler benchmarks (#621), *runtime-defn-ir-cache* retained only for the current namespace (#650).

Graphics (experimental)

• glplat merged as a platform layer with two backend implementations: GLFW/OpenGL, which is cgo-native only, and Ebitengine, which also reaches browser and Metal. Pick one with -tags glplat or -tags glplat_ebiten. The glplat namespace is present in a default, untagged build, but every native in it returns no backend registered and no graphics dependency is linked. #744
• This is explicitly not a stable surface. Per the design decision record, the backend registry stays under internal/, and a planned rt.Display/*display* follow-up may rename natives and change Init's signature. Treat glplat as experimental. #874
• Untagged builds are gated against the GL/Ebitengine subsystems, so x/image and x/text no longer land in every default binary. #789

Tooling and CI

• lint.lg flags breadcrumb and devlog comments (#836), with objective comment-abuse rules R1 through R6 and a code-verbosity catalog added on top (#870).
• A static complexity scorer reports cost, duplication, a score, and call-graph output. #871
• spec-evidence makes fenced code blocks in docs/specs/*.md executable, so a spec and its conformance tests can't silently drift apart. #861
• A provenance-tracked dependency manifest with selective regeneration (#641), now gating every committed generated artifact rather than just three (#683), and gating pushes on manifest freshness (#765).
• A tracked AGENTS.md pointing at a new docs/contributor-workflow.md. #802
• A perf timeline explorer page for the CI dashboard, with several follow-on readability passes: a page-wide CPU filter, a sparkline table, dot sizing, baseline naming. #880, also #879, #886, #887, #888, #889, #892
• CI now reports where GitHub Actions runner time goes. #876

Also: sticky-comment lookup paginated in the perf lanes (#715, #708), the ubuntu perf capture cap lowered to 60 minutes provisionally (#878), Git integration enabled in the tracked VS Code settings (#746), the generated-module scaffolding extracted into pkg/gomod (#741), the makeplus/makes clone pinned to a SHA (#632), openspec design collateral untracked (#643).

Documentation

• docs/guide/os.md documents the OS namespace additions from this and earlier ranges (os/unzip, os/rename, os/delete-tree, os/absolute-path, os/canonical-path). #717
• A first HTTP guide page (docs/guide/http.md) accompanies the networking work above.
• The known-Clojure-divergences catalog, cataloged in #771 and renamed to known-divergences.md for consistency (#825).
• A comment-lint skill page documents how to act on the devlog-comment report (#858), with a page for the linter itself linked from the docs index (#890).
• The TinyGo guide's xxh3 limitation note was corrected. It previously described a substitution that doesn't occur. pkg/rt/interop_xxh3.go is !tinygo-gated, so a TinyGo build has no xxh3 namespace at all, rather than a different digest. #799
• The binary-size and boot-time audit method is published, behind #652. This is the tooling and method, not an audit of this release's own range. #894
• The sums merge driver and conflict-recovery process are documented, closing a real gap for anyone who hits a generated.sums conflict during a rebase. #842
• Devlog comments across the tree rewritten to describe the code as it stands rather than the change that produced it (#846), a Discord invite link added (#785), an IR-pipeline dynamic-vars reference published (#555).

Also

Small, largely internal changes rolled up rather than given their own bullets: #797 (public compile-form in an example), #749/#750 (dependency-manifest refresh after path moves), #633 (lginterop round-trip moved to the expensive e2e lane), #680 (scrub GIT_DIR from compat-suite git calls), #676 (isolate compat-suite const pools per case), #556 (self-heal a drifted clojure-test-suite submodule), #614 (stage the lowered tree in an OS tempdir before copying into place), #630 (emit //go:build constraints from lginterop), #610 (alias-collision guard compares namespace names, not pointers), #784 (report every duplicate manifest entry, not just the first).

Changelog

• 9c9a3d6 fix(wasm): resolve go.sum for released-binary lg -w builds (#594)

let-go v1.12.1

First release since v1.11.1 (2026-06-29). 126 commits in about three weeks,
centered on one theme: running real Clojure libraries unchanged. Stock HoneySQL
now works out of the box, backed by a round of JVM host-compat and exception-
semantics work. Beyond that: a compiler-free runtime binary, a WASI build, TCP
networking, a clearer Go-interop story, substantial AOT progress, and another
round of runtime performance improvements. There are no breaking API removals;
see the upgrade notes for observable behavior changes.

Run real Clojure libraries

The headline: stock HoneySQL runs on let-go unchanged (#494). Getting there
closed a long tail of JVM-compat gaps that benefit any library you try next:

• Mutable java.util.HashMap and ArrayDeque (#512), static method calls
  (#514), and the collection interfaces libraries expect (#510).
• The java.lang exception hierarchy (#472), typed catch dispatch (#476), and
  finally blocks that run on every exit path (#474).
• fn supports :pre/:post conditions (#458), defprotocol accepts standard
  options (#488), and regex match results have Clojure's shape (#456).
• Top-level (do ...) forms evaluate subform-by-subform (#470), and require
  aliases are honored before the core/* shortcut (#548).

Ahead-of-time compilation

let-go has always bundled to bytecode (lg -c) and standalone binaries
(lg -b). This release hardens and extends that pipeline:

• lg-runtime is a compiler-free binary that executes precompiled .lgb
  bundles: compile on your machine, then ship only a runtime and bundle (#424).
• Bundles built against a different opcode set are rejected clearly instead of
  misbehaving (#443), and lowered output is deterministic (#446).
• More language features lower to native Go, including lambda-lifted functions
  (#479), multi-arity direct calls (#371), and fused sequence pipelines (#440).
• Parameters annotated with ^double or ^long can use unboxed Go numerics in
  the native lowering pipeline (#530, #536).
• The refreshed benchmark suite compares the VM with both native-lowered and
  runtime-backed AOT code, and documents why those two paths perform differently
  (#552, #578, #582).

New targets round out where compiled output can run: a WASI (wasip1)
module for any WASI host (#466), real terminal input on Plan 9 (#460, #461),
custom browser shell templates (#377), and an in-browser IR/bytecode/lowered-Go
inspector notebook (#379).

Interop between let-go and Go

• Go to let-go (embedding): api.NewLetGo plus Def hands Go values,
  functions, structs, and channels to the VM.
• let-go to Go (wrapping): lginterop generates smart wrappers around Go
  packages. The guide now walks through database/sql end to end, and an e2e
  test keeps the wrapper path honest (#537, #532, #543, #542).
• Native primitives: the //lg:native annotation lets Go functions back
  let-go builtins directly, including standard-library hot paths (#438).

Start with docs/guide/go-interop.md.

Networking, language, and library additions

• A net namespace with TCP client support plus bencode encoding and framing
  (#526, #533).
• Ring-style HTTP requests now expose request-method as a keyword (#527).
• update-keys, update-vals, ns-publics, find-var, get-method, and a real
  PersistentQueue (#447, #384, #417, #419).
• Base64 and base64url encoding, raw byte-array writes through spit/write!,
  streaming os/exec*, and function metadata (#368, #367, #371, #383).
• core.async now matches Clojure for closed channels: puts return false and
  takes return nil (#391).

See docs/guide/usage.md, docs/guide/net.md, and
docs/guide/clojure-compatibility.md for the newly expanded guidance (#550).

Performance

• Dynamic var lookup is O(1) per var (#462).
• Keyword map lookup and protocol dispatch avoid boxing (#396, #568), while
  vector indexing takes a direct fast path (#398).
• Inferred types moved to a positional side table, making type writes roughly
  100x faster in the measured lowering workload (#558).
• Realized lazy-seq reads gained a lock-free path (#560); Keyword/Int
  equality and string conversion gained typed fast paths (#567, #569).
• Transient maps use their growth reserve (#559), checked integer multiply
  avoids division on its fast path (#571), and all timeouts share one timer
  daemon instead of one goroutine each (#442).

Upgrade notes

No hard-breaking API changes, but a few things behave differently:

• Namespace cleanup: let-go-specific functions that lived in clojure.core
  moved to let-go.core and let-go.types (#410). Update requires for code that
  reached let-go-specific functions through clojure.core.
• Closed channels do not panic: core.async operations on closed channels now
  return false/nil, matching Clojure (#391).
• Recompile old bundles: .lgb bundles built by older opcode sets are
  rejected at load. Rebuild them with v1.12.0 (#443).
• CLI exit codes: lg exits non-zero when a script or -e expression fails
  (#409).
• Ring-style request methods: request-method is a keyword such as :get,
  not a string (#527).
• Tracing: the old trace opcode is replaced by the dynamically scoped
  *lg-trace* facility; recompile bundles and migrate direct trace usage (#407).

Full change and contributor attribution follows.

What's Changed

• fix(bench): per-goroutine sink in Parallel VarDeref benchmarks by @nnunley in #365
• examples: host-eval browser demo (client-owned shell) by @mparrett in #359
• [codex] Derive lg metadata from Go build info by @mparrett in #366
• perf(ratchet): machine-profile baseline + machine-independent alloc gate + interactive multi-machine dashboard by @nnunley in #362
• fix(json,transit): serialize Float32 instead of panicking by @mparrett in #364
• chore: remove accidentally-committed perf-page binary + gitignore it by @nnunley in #369
• fix(ir): chained-comparison lowering + ec/callErr name collision in gogen by @nooga in #374
• feat(rt): spit/write! accept a byte-array (write raw bytes) by @mparrett in #367
• feat(wasm): -w-shell accepts a custom HTML template by @nnunley in #377
• feat(vm): carry metadata on functions (with-meta/meta) by @abogoyavlensky in #383
• feat(rt): add ns-publics by @abogoyavlensky in #384
• fix(vm): resolve empty LazySeq to nil so reduce/some don't see a phantom nil by @nnunley in #388
• refactor(vm): drop now-dead EmptyList guards after empty-LazySeq→nil fix by @nnunley in #389
• docs(clojure-test-suite): document make jank-stress native-lowering coverage gate by @nnunley in #393
• feat(ir,build): lowering-coverage ratchet gate (ITER-0021) by @nnunley in #370
• ci(perf): arm64 timeline leg + auto-backfill of release tags by @nnunley in #363
• chore(git): recompute generated.sums on merge (dedicated 'sums' driver) by @nnunley in #375
• Multi-arity direct calls + self-host coalesce fix, os/exec* streaming, VM Box fast-path by @nnunley in #371
• feat(wasm): neutral #app host mount by @mparrett in #378
• feat(rt): base64-encode / base64-decode builtins by @mparrett in #368
• docs(perf): document the perf label / PR-time A/B workflow by @mparrett in #373
• perf(ci): wasm A/B benchmark gate (perf-wasm label) by @mparrett in #386
• feat(rt): zero-arg (read-line) reads current in by @mparrett in #406
• feat(ir): type math intrinsic call results as :float in typeinfer by @mparrett in #372
• fix(cli): exit nonzero when script or -e fails by @mparrett in #409
• async: core.async parity — buffer policies, closed-channel puts, thread, alts!! by @nnunley in #391
• fix(vm): explicit :refer shadows the clojure.core auto-refer baseline by @nnunley in #408
• chore(perf): re-baseline ir-stress corpus after upstream drift (2347 -> 2366) by @nnunley in #395
• perf(vm): box-free KeywordLookup fast path (-4% native suite allocs) by @nnunley in #396
• feat(wasm): browser-inspector notebook + in-browser IR/bytecode/lowered-Go inspector by @nnunley in #379
• fix(rt): accept padded base64url input by @mparrett in #405
• feat(vm): real clojure.lang.PersistentQueue by @abogoyavlensky in #419
• feat(rt): add find-var and get-method by @abogoyavlensky in #417
• feat(ir): lowering strategy pattern + unified ir.coverage by @nnunley in #387
• feat(ir): combinator inlining + closure devirtualization (opt-in via enable-inline) by @nnunley in #394
• perf(vm): chunked ArrayVectorSeq (growing-from-1) + orderless maps + alloc-free symbol parsing (-34.8% suite allocs) by @nnunley in #397
• perf(rt): ArrayVector direct-index fast paths — eliminate the seq-protocol tax (-19.7% suite allocs) by @nnunley in #398
• Various bug fixes by @ingydotnet in #400
• fix(compiler): allow an empty catch body with a qualified class name by @abogoyavlensky in #413
• fix(core): scope record fields in defrecord protocol-method bodies by @abogoyavlensky in #415
• feat(rt): compile-only Clojure-compat classpath-scan stubs by @abogoyavlensky in #421
• feat(ir): reach typed natives from runtime values by @ingydotnet in #432
• perf(rt/ir): stop (nth string i) allocating the rune slice; O(1) registry emptiness check (−13% lowering allocs) by @nnunley in #402
• perf(ir): transducer-fusion foundation — data-driven pass list + remove arity-1 + transduce≡lazy proof by @nnunley in #434
• perf(ir/typeinfer): worklist membership via in-place transient-map flags (−1GB cloneAndSet) by @nnunley in #403
• chore(perf): refresh ir-stress and benchmark baselines after upstream drift by @nnunley in #437
• docs(vm/allocattr): correct the single-goroutine attribution assumption by @nnunley in #439
• feat(lgbgen): self-hosting lowering — Go overrides + check-selfhost target by @nnunley in #435
• feat(gogen): math.NaN()/math.Inf() emission + go-ast read/COW import bindings by @nnunley in #430
• perf(ir): transient current-locals-flat + reduce-based every? (−270MB lowering) by @nnunley in #433
• feat(ir-stress): tool-maintained coverage baseline — make ir-stress-rebaseline by @nnunley in #404
• refactor(rt,core): purify clojure.core — let-go.core / let-go.types for lg-isms by @nnunley in #410
• fix(core): format time macro elapsed duration as msecs by @nooga in #444
• feat(bytecode): reject .lgb bundles compiled against a different opcode set by @mparrett in #443
• perf(rt): close timeout channels from one shared timer daemon by @mparrett in #442
• test(vm): stabilize BenchmarkVectorAccess — sink result + hoist key boxing by @nnunley in #454
• fix(compiler): parse empty catch bodies with simple class names by @abogoyavlensky in #449
• fix(rt): return Clojure-compatible regex match results by @abogoyavlensky in #456
• fix(core): support the partition padding arity by @abogoyavlensky in #453
• fix(rt): add compile-only Exception constructor stub by @abogoyavlensky in #451
• fix(core): support fn pre and post conditions by @abogoyavlensky in #458
• feat(rt): java.lang exception class hierarchy and constructors by @abogoyavlensky in #472
• fix(vm): run finally on abnormal exits and propagate the exception by @abogoyavlensky in #474
• Typed catch dispatch by @abogoyavlensky in #476
• fix(rt): expose key-pending? on plan9 by @mparrett in #460
• feat(rt): real Plan 9 terminal input (raw mode, read-key, key-pending?) by @mparrett in #461
• bench: YamlStar real-corpus parse benchmark + ITER-0035 gate (#352) by @nnunley in #495
• Build let-go as a WASI (GOOS=wasip1) module by @mparrett in #466
• test(ir): build-stable op baseline for the fold-unroll pipeline tests by @nnunley in #505
• feat(core): add update-keys/update-vals by @nooga in #447
• feat(native-bridge): //lg native-primitive generation — drain hot trampolines (IRCompile −13.6% allocs) by @nnunley in #438
• chore(hooks): reject committing compiled executables (pre-commit/prek) by @nnunley in #465
• chore(ir-stress): exclude scripts/lginterop.lg from corpus — stale gogen/parse-stmts by @nnunley in #467
• fix(vm): ArrayVectorSeq.ChunkedFirst must not mutate the shared seq node (data race) by @nnunley in #463
• fix(compiler): evaluate top-level (do ...) subform-by-subform like Clojure by @nnunley in #470
• Runtime-only build: execute precompiled bytecode, no compiler linked by @mparrett in #424
• perf(vm): per-var root binding chains — O(1) bound deref (Phase 2, stacks on #459) by @nnunley in #462
• feat(ir): loop-fusion (deforestation) — pass, enabled, comp-chains + into by @nnunley in #440
• fix(ir): accept defn attr-map position in AOT lowering by @nnunley in #469
• feat(ir): legalize cross-block refs

Note truncated.

Changelog

• d418eef Brew cask update for let-go version v1.11.0 (#350)
• cf9fcb6 ci(perf): track core-bundle decode (InitFromLGB) in the ratchet (#355)
• 079b9bb perf(bytecode): pre-size source-map / local-var slices on bundle decode (#354)
• 7aef577 perf(startup): exclude ir.* AOT pipeline from the bytecode bundle (#356)

let-go v1.11.0

First release since v1.10.0 (2026-06-08). 109 commits: a browser-runtime host-decoupling arc, native-Go IR lowering across most of the Clojure-compat surface (now emitting typed cross-namespace direct calls), terminal mouse input, and a round of VM and compiler performance work. No breaking changes.

Browser runtime and client-owned shell

The WASM host now talks to Go through typed seams instead of ad-hoc JS shims, and the embedding page can own the shell.

• -w-shell none lets the host page supply its own shell; lg-host.js is split out so a client can drive the runtime directly (#245).
• -w-wasm external ships the payload as a separate streaming main.wasm rather than inlining it (#246).
• Typed host seams: output through a Go HostWriter for *out*/*err* (#231), a HostEmitter for js/emit (#241), a KeySource for term/read-key and key-pending? (#244), and a host-bound storage seam (#315).
• js/url-param reads a query parameter from the launch URL, so a WASM bundle can pick up configuration from the page it's loaded on (#339).
• Native bundles bake a storage store id into the trailer (v3), binding a bundled app to its own storage namespace through the seam above (#336).
• -w-host-eval exposes LetGoHost.eval, letting a JS host evaluate code in a live in-page image; it works in both main-thread and worker boot modes and is gated to host-eval bundles (#340).
• WASM/mobile fixes: a newest-wins non-blocking key producer over a SharedArrayBuffer (#276, #279), viewport meta and dvh height (#291), and an overflow guard on host.html (#277).

Language and runtime

• *command-line-args* in core (#205).
• os/free-port returns an OS-assigned TCP port (#209).
• str/replace and replace-first accept a function replacement, matching Clojure (#216).
• alts! takes a :default for non-blocking select (#250).
• Terminal SGR mouse input: enable/disable primitives and a decoder (#313).
• set-rand-seed! reseeds the runtime RNG for reproducible rand/rand-int/rand-nth/shuffle, backed by a mutex-guarded math/rand/v2 source (#341).
• Profiling: -cpuprofile/-memprofile flags, with LG_CPUPROFILE/LG_MEMPROFILE env fallbacks for generated builds (#331).

Compiler: native-Go IR lowering

The self-AOT pipeline now lowers most of the language straight to Go.

• try/catch/finally (#222), deftype/defprotocol (#232), and set!/binding/var/quote (#249) lower to native Go.
• The jank Clojure-compat surface reaches 100% lowering coverage, gated in CI (#324, #327, #317).
• Typed direct calls: cross-namespace calls into clojure.core and lowered siblings now emit direct Go calls instead of dynamic InvokeValue, built on reified IR op-types and interface-category type classification (#310, #318, #320, #321, #322). The arc extends to hot clojure.core builtins via pkg/rt/builtins (#343), cross-package calls between lowered packages (#345), and a build-call that builds args once in callee-before-arguments order (#344).
• Type-dispatched defmulti/defmethod lower to native Go (#325).
• Correctness fixes: loop bytecode lowering (#214), captured-name shadowing (#247), IIFE head expansion (#254), an O(n²) closure-info blowup that timed out AOT (#280), box-as-value in :try lowering (#316), a fresh-regen nil in ir.passes.purity (#309), and empty-list () lowering to the empty-list constant rather than invoke-nil (#342).

Performance

• Lock-free dynamic-var deref via a persistent frame-list binding stack (#220).
• O(1)-amortized PersistentVector.pop, previously O(n) (#302).
• PersistentMap.Equals compares in place instead of materializing a node seq (#300).
• typeinfer runs on positional transient state rather than HAMT side tables (#301, #305, #306).
• subs no longer materializes the whole string to runes (a124d2d).

Upgrade notes

No breaking changes. A few behavior changes are worth knowing if you embed the runtime:

• print/pr/prn/println and the term/* ANSI control ops now route through *out*, with error sites through *err* (#206, #223). Output and terminal control that previously went straight to stdout now follow whatever those vars are bound to.
• New WithStdout/WithStderr options on NewLetGo bind those streams at construction, scoped per Run (#207).
• The WASM fs.writeSync output shim is retired in favor of the HostWriter seam (#231).
• The source-paths transition warning and LG_SUPPRESS_SOURCE_PATHS_WARNING are removed (#230).

Full commit list below.

Changelog

• 8bbb572 Brew cask update for let-go version v1.10.0 (#202)
• 5acc45e feat(args): add core/command-line-args var (#205)
• 9aa5354 fix(vm): per-namespace RWMutex — make Namespace map access concurrency-safe (F-1) (#203)
• d6d0128 feat(rt): route print/pr/prn/println through out and error sites through err (#206)
• 8b6b545 feat(rt): add os/free-port — OS-assigned free TCP port (#209)
• acd4676 fix(lower-go): make gogen_ir lowering deterministic (4 axes) (#192)
• 531db14 perf(lower-go): exact-key registry resolution (resolve-then-get, no scan) (#193)
• a3572e3 feat(api): WithStdout/WithStderr constructor options (per-Run binding scope) (#207)
• 79196be build: cap Go heap (GOMEMLIMIT) for bootstrap/lowering targets, not just make test (#215)
• 1809ed0 feat(rt): str/replace + replace-first accept a function replacement (Clojure-compatible) (#216)
• c297975 build(lgbgen): single-pass --target=both — emit bundle + go tree from one compile (#212)
• 439b603 feat(vm,ir): ExecContext threading — explicit dynamic-binding + scope context, delete goid (#210)
• 02c9660 Publish Homebrew formula to shared tap (#218)
• 7beb0a4 fix(ir): correct ir-compile bytecode lowering of loops (4 defects) (#214)
• 7d37167 feat(ir): structured Go emission — CFG → if/for tree-walk (lg-dn6u) (#213)
• 45a9bdf Makefile fixes (#219)
• 605ccbd feat(build): content-based regen tracking for generated .lg artifacts (#217)
• db3c396 chore(pre-commit): add checkmake hook (#221)
• fa20c7b perf(vm): lock-free dynamic-var deref via persistent frame-list binding stack (#220)
• e314ded perf(vm): cut redundant value hashing on the lowering hot path (#224)
• 5dfa4c4 feat(lgbgen): CPU profiling for the self-AOT generation process (#227)
• 72a96a3 fix(vm): Indexed collection protocol — correct nth dispatch + chunked-seq/conj semantics (#228)
• ad8ff50 feat(resolver): LG_FORCE_SOURCE_NS for incremental .lg dev loop (#225)
• c8c7553 feat(rt): route term/* ANSI output through out (#223)
• eac88b9 feat(ir): lower try/catch/finally to native Go (gogen_ir self-AOT) (#222)
• c23bae5 chore(source-paths): remove transition warning and LG_SUPPRESS_SOURCE_PATHS_WARNING (#230)
• d4eb364 fix(nrepl): report OS-assigned port under -p 0 (#229)
• 41140ea feat(wasm): route out/err through a Go HostWriter, retire the fs.writeSync output shim (#231)
• 43ff528 docs(design): runtime I/O host-decoupling proposal (status: planning) (#233)
• 9f8df3a ci(perf-timeline): add workflow_dispatch for historical backfill (#236)
• 0d9bad4 ci(perf-timeline): resolve dispatch ref in a script step (support short SHAs) (#238)
• 49ba840 feat(ir): native Go lowering for deftype and defprotocol (#232)
• 6474580 fix(term): tolerate ENOTTY from flush Sync on a file-backed TTY (#237)
• 80683f0 build: keep the readline REPL out of GOOS=js builds (fixes #242) (#243)
• 4e3bbbd refactor(test): move e2e tests under test/e2e + pkg/bundle extraction + root-test guard (#234)
• ad24d9b perf(ir): thread typeinfer state + preserve [:dtype T]; complete numeric typing (#235)
• 9521ca4 feat(rt,wasm,api): typed HostEmitter seam — promote js/emit off the raw _lgEmit lookup (#241)
• 164e8cb feat(rt,api): typed KeySource seam — route term/read-key + key-pending? through a host capability (#244)
• 95aa9c5 feat(wasm): client-owned shell — split lg-host.js, add -w-shell none (#245)
• 7bf8f42 feat(wasm): -w-wasm external — ship the payload as a separate streaming main.wasm (#246)
• 0a87097 ci(gold-differential): pin the Clojure toolchain, drop the makeplus curl|make install (#248)
• e2aeace fix(ir): prefix closure-local arg names to prevent captured-name shadowing miscompile (#247)
• cbe5abf feat(async): alts! :default for non-blocking select (#250)
• e712fa6 docs(design): mark runtime-I/O decoupling shipped; refresh status (#261)
• 3d40e7e fix(generate): clean lowered-tree target dir before regen (hermetic generation) (#240)
• 9b844d3 fix(genmanifest): exclude generated Go from digest; gate before regen (#252)
• b9c3399 fix(ir): expand-all must expand fn-expression heads (IIFE) (#254)
• 6a0a8b4 fix(reader): read-string skips leading no-value forms (#253)
• d4c36cf fix(lang): def/declare forward-declaration promise semantics (#251)
• 23bfd87 feat(ir): native-Go lowering for set!/binding/var/quot + self-AOT diff harness; fix cluster-A engine divergence (#249)
• 83f650d fix(wasm): non-blocking SAB key producer — newest-wins, never block main thread (#276)
• 329743a fix(wasm): add min-height:0 to host.html #terminal so client content can't overflow the frame (#277)
• 6126423 perf-page: relative-% timeline charts (#278)
• d159b84 fix(wasm): drop SAB key when slot still pending, don't overwrite mid-consume (#279)
• 2a72e40 docs: focus the README, move feature how-to into docs/guide/ (slice 1) (#273)
• f7c91ee test(ir-stress): pre-declare deftype/defrecord/defprotocol generated names (#287)
• c6f65ef fix(ir): memoize closure-info* per-nid to kill O(n^2) AOT lowering timeout (#266) (#280)
• c9e6092 test(ir-stress): eval top-level (require ...) forms so deps load (#288)
• 8087f99 fix(wasm): host.html viewport meta + dvh height for mobile (#291)
• 2aa2e0c build(lgbgen): nest lowered-Go output to mirror namespace nesting (#297)
• e9bcdcd fix(ir-stress): close the (do ...) wrapper on its own line in read-all (#295)
• 5547d78 feat(gogen): elide callErr check for total keyword-callee calls (#294)
• 65882d6 feat(gogen): make the gogen macro layer usable by the IR lowering pipeline (#286)
• 1375e81 docs: reorganize docs/ — design consolidation, layout rule, pods split
• d67c739 fix(term): tokenize read-key so a key burst yields one event per key
• 46b1027 refactor(term): fold the key tokenizer into a single-pass scanner
• ba8488c perf(vm): O(1)-amortized PersistentVector.pop (was O(n) Unbox+rebuild) (#302)
• 64feeec fix(term): flush on piped stdout
• a124d2d perf(rt): subs without materializing the whole string to runes
• 5f06d34 perf-tooling(fanout): gate on lg->go expansion ratio + portable os/ls walk (#285)
• b67d684 feat(lg): add -cpuprofile and -memprofile flags
• 73ff475 feat(term): SGR mouse input — enable/disable primitives + decode (#313)
• 9665f5a perf(ir): source-infos in a positional side table, off the inst tuple (#306)
• e55bcd9 perf(ir/typeinfer): positional transient-vector state (Indexed-RPN), not HAMT side tables (#305)
• d646fdf perf(ir/typeinfer): build-deps via transients, not atom+swap!+assoc (#301)
• 1a04328 perf(vm): PersistentMap.Equals walks in place instead of materializing nodeSeq (#300)
• c3d0109 ci(pages): add workflow_dispatch trigger (#319)
• ff28da0 ci(codeql): bump CodeQL action v1→v3, checkout v2→v4, add permissions (#323)
• 892a25c feat(ir,scripts): jank lowering-coverage gate + canonical fn enumeration (#317)
• 5fc3d96 feat(rt,wasm,api): add host-bound storage seam (#315)
• 5dd810e feat(ir): lower the full jank Clojure-compat surface — coverage gate 65% → 100% (#327) (#324)
• c553565 ci(perf): same-runner A/B microbenchmark check on PRs (#328)
• 511a0bf perf-page: CPU-tier filter and selectable baseline; release-baseline recapture (#329)
• 4714b53 perf(bench-ratchet): add named -profile with a curated pr-fast profile (#330)

Note truncated.

Changelog

• bdab027 Brew cask update for let-go version v1.9.0 (#139)
• 7f8d720 Minimal compatibility with weavejester/medley (#157)
• 9b7e7a1 Out-of-SSA Go lowering: lineage coalescing, dead-store elimination, const-param inlining, loop-closure capture (#142)
• ef13bac build: consolidate generated-artifact gates into make check-generated (#162)
• 60731cf build: coordinate the code-generation pipeline in scripts/generate.lg (#163)
• 2457fce build: fix + install the core_compiled.lgb merge driver; add a content freshness gate (#152)
• 6b69c99 docs(readme): document :lg reader-conditional portability convention (#132) (#161)
• 18aed18 feat(bytecode): carry local-variable names as debug info in the bundle (#131)
• c572516 feat(core): Comparable protocol + let-go.semver (versions, ranges, sha) (#160)
• 779bab8 feat(core): faithful print-method dispatch (#179)
• b27111c feat(core): hybrid ir-compile — fall back to bytecode for unlowerable defns (#191)
• af87844 feat(core): mutable deftype fields (^:mutable / ^:unsynchronized-mutable) (#135)
• a454199 feat(core): namespaced and :syms associative destructuring (#150)
• 7b0d457 feat(core): upstream clojure.core fns from the malli shim (#181)
• 2050fe8 feat(examples): revive the malli-on-let-go shim example (#172)
• 4af8cea feat(lower-go): cross-ns IFn dispatch via cached vars (rt.CachedVarFn) (#189)
• ef72a92 feat(lower-go): intra-namespace direct-call lowering (slice 1) (#168)
• 9e870fb feat(lower-go): registry-driven intra-namespace direct-call lowering (slice 2) (#188)
• fe6c6e2 feat(math): expose the math namespace as clojure.math too (#156)
• 098f55b feat(os): add os/exec* — run a command with inherited stdio (#154)
• de8d3ee feat(reader): don't require type-hint tags to resolve as vars (#141)
• d57d0cd feat(reader): match :bb reader-conditional feature (opt-in) (#136)
• 64f53fc feat(rt): 3-arg deref (blocking deref with timeout) for promises/futures (#140)
• 64501a2 feat(rt): bytecode bundle disassembler (lgb -> round-trippable EDN) (#184)
• cfb7654 feat(rt): compare-and-set! for atoms (#137)
• 6db26f2 feat(rt): lazy var roots, bound?, defonce; own-ns access to private vars (#147)
• ee129db feat(rt): pluggable host-method-dispatch seam (#138)
• 0e4e4cd feat(rt/term): wake read-key on SIGWINCH via BEL self-pipe (#165)
• 98a5d21 feat(semver): require-letgo (Layer 3) + npm/cargo range sugar (Layer 4) (#132) (#164)
• de92b59 feat(source-paths): explicit -source-paths/LG_SOURCE_PATHS fully define the search path (#199)
• fdacba3 feat(string): add clojure.string/replace-first (#153)
• 430b72d feat(tooling): fanout-ratchet — generated-code-size gate (#171)
• 7fcac88 feat(vm): make Protocol and deftype/reify instances metadata-aware (IMeta) (#187)
• 91be848 feat(vm): set-field! primitive for in-place deftype field mutation (#133)
• c71ba4d feat: Add io/resource with -resource-paths roots and -b binary embedding (#178)
• 5c5f434 feat: browser interop (js/emit + LetGoHost API) (#174)
• 664b13c feat: invokable (IFn) + derefable (IDeref) protocols (#158)
• f593010 fix(compiler): correct lexical binding resolution (#144)
• 1d906cd fix(core): binding must restore dynamic vars on non-local exit (#185)
• 81dcc4f fix(core): deftype/defrecord/reify/extend-protocol macro hygiene (#151)
• a9e35b4 fix(core): ns :require is load-only; run-tests runs each ns's tests in its home ns (#149)
• f9037fb fix(core): thread reader metadata through defmacro so ^:private works (#180)
• b0dd737 fix(lower-go): deterministic gensym naming so lowered Go is reproducible (#182)
• 9dcbdc7 fix(lower-go): unbox vm.Value -> primitive at branch-edge copies (#166)
• 79d26c8 fix(reader): fully skip non-matching reader-conditional branches (#145)
• 8734dde fix(rt): find returns a MapEntry; pop drops the first element of a one-item seq (#148)
• 873cb79 fix(vm): emit EDN-conformant string escapes from pr-str (#183)
• 7930fb1 fix(vm): type dispatch — Object default, instance? on protocols, deftype fields, re-pattern (#146)
• ab99a52 perf(timeline): perf-data branch, execution-only suite, 3 IR exec variants (#190)
• b8c37fc perf: add timeline page and main snapshots (#173)
• 74d4ec6 test(bench): fixed-workload program benchmark from benchmark/*.clj (#170)

Changelog

• 17ad803 Add term/key-pending? non-blocking input peek (#118)
• 0044979 Brew cask update for let-go version v1.8.0 (#74)
• 1738270 Fix HTTP response header string rendering (#102)
• dbb3403 Fix error output (#87)
• a34de76 Thread doc metadata through def forms (#100)
• 155b9b0 chore(pre-commit): bump golangci-lint to v2.12.2 to match v2 config (#93)
• d037132 compiler/reader: namespace-qualify bare symbols in syntax-quote (#91)
• 49dd47b docs(policy)+ci+devx: contribution policy + staleness gates + parity tooling (issue #97) (#117)
• 3987b28 feat(bytecode): LGB v2 format with per-tag versioning and batch decode (#80)
• 4b726d8 feat(core): graph ns (toposort, Tarjan SCC) + read-all-string + scripts/sort-defns.lg (#98)
• 896316d feat(ir): SSA IR + Lisp-side pass pipeline (#77)
• 8de2d04 feat(ir): band2 — variadic, tail-call, destructure, multi-arity, type-infer (with review fixes) (#94)
• d2d75d9 feat(ir+scripts): substrate observability + small ops + IR-stress harness (#114)
• 86e724f feat(perf): bench-ratchet system + v1.8.0 historical baseline (#119)
• 4fc5f34 feat(rt+vm): xxh3 namespace via lginterop + .lg wrapper (#108)
• 2154e3f feat(vm): Scope — hierarchical goroutine supervision tree (draft, depends on #120) (#123)
• 941cbe5 feat(vm): surface Go panic origin in crash reports (#127)
• 44d0ea4 feat(vm+rt): chunked seqs — substrate + chunk-aware map/reduce/filter/take/pmap (#109)
• f9565e8 feat(vm+rt/async): goroutine registry + cancellable, correct core.async primitives (#120)
• a58b323 feat/perf(ir): multi-arity closure captures + uses-cache infra + typeinfer overhaul + lower-go enhancements (#116)
• 4c40934 feat: support .clj namespace resolution + LG_READ_CLJ env var (#129)
• 5f7556c fix(compiler): in-ns compile-time hook must not trigger ns reload (#78)
• f754a37 fix(ir): build/lower minor bug fix bundle (#113)
• 60da8be fix(rt): identity short-circuit + hash fast-reject + visited-pair memoization in valueEquals (#111)
• 987c6f5 fix(rt+resolver+lgbgen): land the missing call-site switches for #110 (#115)
• efce979 fix(rt/term): guard syscall/js Value.Int() against undefined Atomics/SAB (#126)
• cbc22c8 fix(scripts): atomic gofmt write via .tmp + mv; trap cleanup (#92)
• 8d7dca2 fix(string): index-of / last-index-of return rune indices for UTF-8 safety (#89)
• d2b7474 fix(test): make os-cwd-test hermetic — assert string, not checkout path (#121)
• aa4bd55 fix(vm): Go-fn-call-boundary fixes + Closure as Fn interface (#112)
• 8bac483 lginterop: compact positional exports, generics/methods/fields metadata (#85)
• 3ed77c7 perf(bench-ratchet): default to fast jank-suite gate (bytecode + gogen_ir variants); -full for the micro-bench fleet (#125)
• 6035aa3 perf(gogen): lazy AddLine for synthetic positions (#95)
• 517d129 perf(rt): atomic gensym + pmapv (eager parallel map), and a design note (#124)
• a898a39 perf(vm): lock-free Var.Deref — atomic root/curr instead of global bindingsMu (#122)
• bc9b02c refactor(rt+resolver+lgbgen): reduce binding-add ceremony to a single drop (#110)
• 0051e63 repl: migrate from alimpfard/line to chzyer/readline for FreeBSD support (#90)
• ecc0584 resolver: deps.edn source path support + runtime deps-paths fn (#83)
• ba082de runtime: enforce ns load semantics for require and qualified lookup (#81)
• 06bd643 scripts: corpus-agnostic ir-stress harness (#96)

Changelog

• ff2ec36 Brew formula update for let-go version v2.0.2 (#31)
• e2e5ffa Fix Homebrew formula PR merge branch (#32)
• d733e03 Migrate Homebrew release to casks
• 3dd9949 Some improvements to Makefile and report generator
• 5a63816 chore(tooling): git merge driver for core_compiled.lgb
• 5dc9ad8 ci: add prek-compatible pre-commit hooks mirroring CI
• a43d69d examples: ys-on-let-go — run yamlscript compiled output on let-go (#53)
• 7df8031 feat(core): add unchecked-add/-subtract/-multiply/-negate/-inc/-dec/-divide-int for Clojure parity
• de06636 feat(gogen): Clojure-to-Go AST codegen library
• 1abc5cb feat(gogen): add func-lit, switch, composite-lit
• 02b1b4f feat(reader): promote overflowing hex literals to BigInt — Clojure parity
• de4668a feat(rt): unchecked-* coercion family — long/int/short/byte/char/float/double
• fcdbdea feat(vm): warn on def shadowing clojure.core — Clojure JVM parity
• 96bebc6 feat(vm/string): add .getBytes interop — returns UTF-8 byte-array
• e3dcf11 feat: add check ns for property testing
• a1824d4 feat: add lazy-seq? predicate; throw on lazy-seq of non-seq value
• 693cd4d feat: add walk/keywordize-keys and walk/stringify-keys
• 9ef4cc2 feat: preserve laziness via vm.Iter + SeqToSlice + reflect bridge
• 18fc2da fix(compiler): allow multiple _ parameters in fn arg lists
• b8d0ff2 fix(compiler): recurCompiler must count slots, not distinct names — fixes loop+shadow stack overflow
• 1ca8567 fix(vm): warn-on-core-shadow only fires when name is referred in
• 2c97d2e fix: COI service worker passes through server headers, uses require-corp
• 711f2bc fix: RegisterNS auto-refers CoreNS so (in-ns 'foo) preserves core macros
• 33ee8e7 fix: bootstrap stdlib lgb generation from source
• fa6d96b fix: guard COI service worker against reload loops, unregister when redundant
• 6f1f276 fix: make lgbgen output bit-deterministic
• 8442bbc fix: make map and mapcat lazy
• 38011c6 fix: normalize empty Sequable in lazy-seq
• e32debd fix: support docstrings and attr-map on defmulti and defprotocol
• 325a73b fix: walk handles maps via map-entry? predicate
• d0c0d76 style: apply gofmt -s and golangci-lint fixes to existing files

Changelog

• 941bbd0 Update sort compatibility gates

Changelog

• d8543c4 Add -source-paths flag and LG_SOURCE_PATHS env var
• 92fe5e2 Add JVM compatibility shim plan
• c01ee76 Add execution plan for Clojure compat work
• 5c71688 Correct JVM compat plan: dot-method dispatch already exists
• 1120fcb Fix ineffectual ch assignments in readMeta
• 430d531 Fix sort comparator compatibility
• 9a033b1 Fix typo in README
• af894a3 Improve real-world Clojure source compatibility
• 75fbcb6 Pre-flight cleanups for Clojure compat (P1-P5)
• 137b6d0 Refactor benchmarks and README for clarity and performance
• 1598930 Unskip clojure-test-suite files: ancestors, parents, add_watch, remove_watch
• 5a6b933 Update Homebrew formula to v1.7.2
• f448204 Update benchmark results: add gloab/glojure back
• a15aae9 Update website

Changelog

• dd53ddb Add go-joker support to benchmark scripts and documentation
• 8359258 Add plan9 port and release pipeline
• 46ce159 Strip ANSI escapes on plan9
• 9b1d56b Untrack CLAUDE.md and committed .DS_Store files
• 5abb6f6 Update Homebrew formula to v1.7.1