Changelog

Latest release changes

GoLazy v0.1.16 adds cache primitives, deferred template values, route-link template helpers, OpenTelemetry-backed request telemetry, and a richer lazydev development panel. Existing v0.1.15 applications do not need source rewrites; run lazy upgrade --target v0.1.16 to update the golazy.dev module requirement and follow-up checks.

Framework

• lazyapp.Config.Dependencies now receives a framework-owned *lazydeps.Scope. Applications initialize services through lazydeps.Service, update the app context through the scope, and let GoLazy record the dependency graph for later lifecycle work. Read Application Startup and Dependencies And Services.
• lazyapp.Config.SEO now receives the dependency-initialized app context and is normally wired as SEO: SEO with the function defined in init/seo.go. Read SEO And Sitemaps.
• Sitemap generation is now opt-in. GoLazy does not serve an empty /sitemap.xml by default, and robots.txt only advertises a generated sitemap after lazyapp.Config.Sitemap is configured.
• golazy.dev/lazyconfig fills application config structs from environment variables with Getenv[T] and MustGetenv[T], default field naming, var, default, required and require tags, trimmed string/numeric/bool values, pointer scalar fields, []string splitting, case-insensitive bool parsing, slice entry loading, and optional Validate() error support.
• SEO helpers support image alt text, Open Graph image dimensions, secure social image URLs, article:published_time, and complete-title preservation. Read SEO And Sitemaps.
• golazy.dev/lazytui/progress provides named task progress, captured output, warnings, mise command helpers, and UI takeovers for interactive terminal steps.
• golazy.dev/lazyerrors provides application-owned errors that format like fmt.Errorf, prefix messages with the caller, preserve single and multiple %w wrapping, and expose recorded []lazyerrors.Frame backtraces.
• golazy.dev/lazytelemetry provides OpenTelemetry-compatible environment config, request-id middleware, context-aware slog logging, OpenTelemetry-backed spans, log-to-span events, OpenTelemetry meter measurements, and in-memory request metrics. lazyapp.New installs telemetry automatically when meaningful OTEL_* environment variables are present, mounts Prometheus text metrics on the control plane when OTEL_METRICS_EXPORTER=prometheus and CONTROL_PLANE_ADDR is set, and includes lazycache stats in that scrape output. Production builds do not expose control-plane metrics on the public app listener when CONTROL_PLANE_ADDR is unset. OTEL_SDK_DISABLED=true disables telemetry. Lazydev builds can also record per-request Go runtime traces, span JSON, and request-local log JSONL under .tmp/traces when OTEL exporters are present. Read Telemetry.
• The latest telemetry guide now documents the Kubernetes production shape: ingress-nginx OpenTelemetry is enabled per Ingress but collector and sampler settings live on the nginx controller ConfigMap; Prometheus Operator scraping should use PodMonitor resources for the GoLazy control-plane /metrics endpoint.
• lazyapp now layers application views over framework default views from lazycontroller, so controller errors render a built-in mobile friendly app/error page unless the app provides app/views/app/error.html.tpl. Raw error details plus lazyerrors and panic backtraces are exposed to that view only in development/detail mode. The built-in view shortens frame paths relative to the workspace, current directory, module cache, or module path where possible, and lazydev can open a clicked frame in $EDITOR, using VS Code's -g file:line form or a discovered terminal for terminal editors. New apps can rely on that framework view and add app/views/app/error.html.tpl only when they want a custom error page.
• lazycontroller.Base now provides SetLater and SetWhenNeeded for request-local deferred view data. They store a Valuer under the template key and let templates call {{.name.Value}} while the controller can still use the returned value directly. Read Template Data And Helpers.
• Templates can use link_to with path_for, attr, data, and unless_current to render route links without handwritten anchor tags. Read Template Data And Helpers.
• golazy.dev/lazycache provides the cache contract, typed Get / Set helpers, standardized stats, and On / Off switching. lazyapp installs a default in-memory backend, exposes App.Cache, and registers controller, partial, and Turbo frame body caching helpers. The development panel exposes cache stats, keys, and On/Off actions through the lazydev control plane. Read Caching.

CLI and generated apps

• lazy new now trusts the generated app's mise.toml, runs mise install, validates with the current go on PATH, then initializes a fresh Git repository and commits the generated checkout with a command-local GoLazy identity.
• lazy new checks https://golazy.dev/lazy.version before remote template generation, supports --skip-update-check, and accepts --version <version> for a specific sample app tag.
• Generated apps pin their mise-managed age, sops, and usage helper versions instead of using latest, so fresh mise install runs do not need a release-list lookup to decide the version.
• LAZY_MULTIVERSION=off disables app-version CLI handoff for local testing, replacing the previous global --skip-version-check flag.
• Go subprocesses in lazy new, lazy, lazy routes, lazy upgrade, and the app build step of lazy native build use the current go on PATH. lazy js and lazy tailwind still run app-managed package-manager tools through mise exec.
• The default lazy development command runs go mod tidy before building the app only when Go workspace mode is inactive. If GOWORK or go env GOWORK points at an active workspace, lazy skips the tidy step.
• The default lazy development command now uses compact progress output for proxy startup, generated-asset work, Go builds, and application starts while leaving the running app's own output attached to the terminal.
• The default lazy development command now serves a GoLazy development panel at /_golazy/, keeps it available across build and runtime failures, and starts the target app's development control plane on a separate internal address for route inspection, view-cache reloads, and cache inspection.
• The development panel now uses a DevTools-style tabbed shell, carries the current App Logs and Actions behavior into that shell, and embeds itself as a fixed bottom iframe on proxied app pages instead of only showing a floating activator button. A UI-only unpacked Chrome DevTools extension prototype lives in chrome-extension while the shared panel API contracts are designed.
• The default lazy development command now assigns X-Request-ID and traceparent before proxying app requests and starts the child app with OTEL trace and log exporters enabled for lazydev request artifacts.
• lazy now passes local view and public roots to lazydev builds with build-time variables. Development assets are served from disk by logical path without permanent hashes or cache headers.
• View-only changes in lazy development now reload the running app's view cache through POST /views on the app's development control plane instead of rebuilding and restarting the app. Public-only changes reload the browser without rebuilding because development assets are read from disk.
• lazy upgrade includes the v0.1.14 to v0.1.15 dependency initializer and SEO initializer migrations, and recognizes v0.1.16 as the next module-only upgrade target. It also uses compact progress output while still letting conflict diffs and prompts take over the terminal deliberately. Read the Upgrade Guide.
• lazy upgrade applies go.mod dependency manifests with go get instead of rewriting module files directly, and it updates mise.toml tools through a tool manifest that comments obsolete entries rather than deleting them.
• lazy upgrade file manifests now hash sample-app additions, replacements, and removals. Unchanged template-owned files are updated or removed directly, new files are created directly, and customized files ask for a dated backup, deletion, keep, or abort choice depending on the operation.
• lazy --version now reports v0.1.16, so lazy new selects the matching sample application template once the coordinated release is published.

Website and guides

• The public installer installs golazy.dev/lazy, writes the binary to a predictable local bin directory when GOBIN is not set, tries the official shell-specific mise installer for bash, zsh, or fish, falls back to the plain bootstrap, and points new apps at lazy. Its same-shell recovery path now keeps lazy on the normal PATH so direct Go subprocesses still find go.
• The homepage and package pages emit richer social-card metadata using the new SEO helpers.
• The latest guides document the in-development v0.1.16 changes while v0.1.15 stays frozen as the previous release snapshot.

Read the Upgrade Guide before moving an existing application forward.