Epic: Footprint & constrained targets

[mparrett]

Umbrella for shrinking what let-go ships and widening where it runs: binary size, the embedding surface, and alternate runtimes (WASI, TinyGo, small native). Distinct from lowering/codegen (#258), which makes code native and fast, and from runtime performance (#464), which keeps the running VM's hot paths fast. Here the metric is bytes on disk, resident memory, and whether let-go links and boots on a given target at all. The one real intersection is boot cost: compressing the embedded core (#502) trades startup time for size, and that tradeoff is called out where it lands.

The goal is a single roll-up so footprint and target-reach work is visible and prioritizable, rather than living inside whichever PR happened to need it.

Compiler-free / embedding surface

Running precompiled bytecode without linking the reader, compiler, and resolver: a smaller binary and a smaller, more stable embedding surface.

• Runtime-only build: execute precompiled bytecode, no compiler linked #424 runtime-only build: a lg-runtime that executes precompiled .lgb with no compiler in the binary.
• feat(rt): BootCore() — compiler-free clojure.core load for AOT/embedded binaries #499 rt.BootCore(): compiler-free clojure.core load, so an AOT-lowered or embedded binary can reach the .lg-defined core without the compiler's eval path.

Bundle size

The .lgb bundle format and the embedded core are stored uncompressed; compressing them trims the shipped artifact and every binary.

• .lgb bundles benefit from compression; add opt-in body compression #500 tracking issue: .lgb bundles carry no compression (3–4.4x headroom).
• feat(bytecode): opt-in DEFLATE compression for .lgb bundles #501 opt-in DEFLATE compression for program bundles (lg -c -z / -b -z).
• feat(lgbgen): compress the embedded core bundle (default off) #502 compress the embedded core_compiled.lgb (the universal per-binary win), with the boot-cost measurement.
• Strip debug sections from the embedded core and -w bundles #631 strip debug sections (source maps + local-var tables) from the embedded core and -w program bundles — the complementary lever to feat(lgbgen): compress the embedded core bundle (default off) #502 (removes the data rather than compressing it; the two compose).

Alternate runtimes & platforms

Targets beyond native and browser-js, where footprint, the host capability model, and cross-target build discipline matter most.

• Build let-go as a WASI (GOOS=wasip1) module #466 build as a WASI (GOOS=wasip1) module: standalone wasm, host gated capabilities, standard-Go 64-bit int.
• TinyGo: the size-optimized runtime lane (much smaller wasm, lower native RSS), and the boundary it hits. Tracking issue: TinyGo as the size-optimized runtime lane — findings, blocker, and the hard boundary #504.
• Plan 9 (fix(rt): expose key-pending? on plan9 #460 / feat(rt): real Plan 9 terminal input (raw mode, read-key, key-pending?) #461): the native GOOS=plan9 port. Footprint isn't the driver here; portability and perf-under-emulation are (that perf side is Epic: Runtime performance & concurrency #464). It's listed for the shared "does let-go link and boot on this target" thread and the cross-target build gates, the same discipline as Build let-go as a WASI (GOOS=wasip1) module #466's wasip1-build job and the one the TinyGo lane would want.

Merged enablers

Already-landed work this epic builds on, listed so the footprint story reads as one arc rather than scattered history:

• refactor(rt,core): purify clojure.core — let-go.core / let-go.types for lg-isms #410 purified clojure.core into let-go.core / let-go.types, the split that made a compiler-free core load feasible.
• perf(startup): recover cold-start regression (16ms → 5.1ms) #356 recovered the cold-start regression (16 ms → 5.1 ms); the core-bundle decode dominates boot.
• ci(perf): track core-bundle decode (InitFromLGB) in the ratchet #355 / perf(bytecode): pre-size source-map / local-var slices on bundle decode #354 track core-bundle decode in the perf ratchet, and pre-size its slices.
• feat(wasm): client-owned shell — split lg-host.js, add -w-shell none #245 / feat(wasm): -w-wasm external — ship the payload as a separate streaming main.wasm #246 client-owned wasm shell and external streaming payload, shrinking the browser boot surface.
• feat: Add io/resource with -resource-paths roots and -b binary embedding #178 / feat(bundle,lg): bake storage store id into native bundles (v3 trailer) #336 io/resource embedding and the v3 native-bundle trailer.
• feat(bytecode): LGB v2 format with per-tag versioning and batch decode #80 the LGB v2 bundle format these build on.

Workflow

File footprint and target-reach issues here as sub-issues: binary/bundle size, embedding-surface reductions, and new-target enablement (with the build recipe and the measured size/RSS delta). Each child should stand on its own; this epic tracks the set and its progress. Boot-cost regressions belong to #464 when the cause is the running VM, and here when it's the size/startup tradeoff of a footprint change.

[nnunley]

It might make sense to pull in the generated go skeleton from #425 as one of the goals for this. If we generate the main form the AOT, that would should be able to use AOT to do the tree-shaking/minimization that would help this come closer to the bare minimum for a constrained target.