Logs-only progress mode

A logs-focused progress frontend streams output directly with no dot noise. It is easier to scan in terminal-first workflows and CI logs.

dagger --progress=logs call ...
# or
DAGGER_PROGRESS=logs dagger call ...

Targeted local-cache pruning

Manual local-cache pruning now supports explicit space thresholds, so teams running with automatic GC disabled can prune predictably without changing global policy.

Set per-call overrides for max used space, reserved space, minimum free space, and target space.

More reliable Git SSH auth and persistent cache

Dagger now handles mixed SSH agent socket paths on the same repo more reliably, and nullable return types no longer skip persistent cache handling.

Hardened local metadata storage

Engine bbolt settings were aligned across metadata DB paths to avoid a known panic path under NoSync, reducing crash risk in heavy-load and shutdown-edge cases.

Dockerfile ONBUILD now publishes correctly

directory.dockerBuild().publish() now preserves ONBUILD instructions in published images.

Dagger Generate

We added dagger generate for code and config generation workflows. Mark generator functions in your module, return Changesets, and Dagger runs and merges them in one pass.

Great for generated clients, repo scaffolding, and config drift cleanup without stitching together shell scripts.

dagger generate

SSH mounts in Dockerfile support

Directory.dockerBuild now supports RUN --mount=type=ssh. Existing Dockerfiles that pull private Git repos or packages work without extra wrappers.

AWS secret providers

Dagger now supports AWS Secrets Manager and Parameter Store as first-class secret providers, so modules can consume cloud-managed secrets directly.

Faster module loading in large monorepos

Reduced overhead when loading modules in very large trees. This improves startup and iteration speed where monorepo scale used to dominate runtime.

Go SDK got more Go-native

Go SDK generation now leans more on external libraries and cleaner module boundaries, with deterministic codegen improvements introduced earlier in the series.

TypeScript SDK improvements

TypeScript workflows got smoother across live telemetry, test tracing, and generated client behavior. We also fixed multi-client tsconfig.json conflicts.

Code generation uses less memory

dagger develop --recursive now handles large module graphs with much lower memory pressure, which makes codegen workflows more stable at scale.

File metadata API

directory.stat() and container.stat() expose metadata directly through the API, removing brittle shell parsing for common file-inspection tasks.

No more surprise Git credential popups

Dagger now disables Git askpass prompts to avoid unexpected IDE credential dialogs. If credentials are missing, it fails early with a clear error instead.

JSON API

Lightweight JSON edits are now practical inside Dagger pipelines. Instead of shelling out to jq, read, modify, and write JSON through typed APIs.

@func()
async setPackageManager(src: Directory): Promise<Directory> {
  const updated = src
    .file("package.json")
    .asJSON()
    .withField(["packageManager"], dag.json().newString("pnpm@10.5.2"))

  return src.withFile(
    "package.json",
    dag.file("package.json", await updated.contents({ pretty: true })),
  )
}

Faster file copies

WithDirectory and WithFile were optimized to avoid unnecessary disk copies in more cases, cutting avoidable I/O overhead in common workflows.

Azure DevOps Server module loading

Dagger can now load modules from self-hosted Azure DevOps Git servers, which unblocks teams running enterprise Git infrastructure outside GitHub and GitLab.

Dagger Checks

dagger check gives module developers one command to run validation anywhere: local dev, CI, and agents. Define checks once, run them consistently everywhere.

Checks are supported in Go, Python, and TypeScript, with Java support added in v0.19.11.

dagger check

dagger check -l

dagger check 'lint-*'

Faster system execution under load

System internals now do much less disk syncing and lock contention in hot paths, improving throughput for heavy concurrent workloads.

Function Cache Control

Before this change, Dagger cached all system functions but not module developers' own functions. We couldn't safely infer purity from side effects, so default caching could have broken behavior.

Now module developers can explicitly set cache policy per function. With explicit control in place, default caching can improve performance safely.

@func() // pure function: default TTL caching
async test(): Promise<string> { ... }

@func({ cache: "15m" }) // refresh external data periodically
async latestBaseDigest(): Promise<string> { ... }

@func({ cache: "never" }) // side effects: always execute
async deploy(): Promise<string> { ... }

Run Dagger without Docker

Dagger CLI added first-class support for Podman, nerdctl, Finch, and Apple's container tool, so the system can start with whichever runtime is already installed.

Import and export local container images

Loading and saving images between your host and Dagger became a first-class API flow, replacing manual docker import and docker export glue.

Changeset API

The new Changeset type lets module developers return a directory diff as an artifact, so generated files can be previewed and applied cleanly from the CLI.

Container.combinedOutput

Need stdout and stderr exactly as emitted? Container.combinedOutput returns a single merged stream, so module developers can handle real command output without stitching streams back together.

dagger shell -c 'container | from alpine | with-exec ls,-l,/etc/fstab,/etc/non-existent --expect=any | combined-output'

Address API

The new address API exposes Dagger's CLI-style reference parsing to modules, so module developers can turn user input into typed objects without reimplementing parsing logic.

Cloud.traceURL

Modules can now fetch the current Dagger Cloud trace URL directly. This makes it easy to publish clickable run links in logs, summaries, and CI notifications.

traceURL, err := dag.Cloud().TraceURL(ctx)
if err != nil {
  return "", err
}
return traceURL, nil

Git reference introspection APIs

Git-heavy modules got better primitives for reasoning about repository state: gitRepository.url, gitRepository.branches, gitRepository.latestVersion, and gitRef.commonAncestor.

Together, these APIs make it much easier to resolve origins, enumerate refs, pick stable versions, and compute merge bases without shelling out.

TypeScript SDK cold starts cut by ~50%

TypeScript SDK initialization got substantially faster through bundling and runtime provisioning improvements, reducing iteration friction during local development.

Dagger Shell

Dagger Shell brought bash-style syntax to Dagger's typed, container-native execution model. You get shell ergonomics with cached, reproducible pipelines and sandboxed-by-default execution.

It also made it easier to compose bigger workflows in one place: simple shell pipelines for day-to-day work, code when logic grows, all on the same system.

container |
  from alpine |
  with-exec apk add git

TypeScript SDK now supports Deno

The TypeScript SDK added Deno runtime support, extending cross-runtime compatibility beyond Node and Bun for module developers.

Java SDK

Java developers got an SDK path to define Dagger workflows and module functions directly in Java.

PHP SDK (Community)

The PHP ecosystem gained a community-maintained SDK, making it possible to author Dagger modules and automation workflows in native PHP.

1Password secret provider

Dagger added direct integration with 1Password so secrets can be resolved at runtime from your existing password manager, instead of being preloaded manually.

HashiCorp Vault secret provider

HashiCorp Vault integration landed as a native secret provider, enabling secure secret retrieval directly inside pipeline execution.