Dagger — Programmable CI/CD Engine

What it is

Dagger is a programmable CI/CD engine that replaces YAML-based pipeline configurations with real programming languages. You write pipelines in Python, Go, TypeScript, or any language with an SDK, and run them locally on your laptop, in any CI system, or in the cloud. Every step runs in a container with automatic caching.

DevOps engineers and platform teams frustrated with debugging YAML indentation and vendor-specific CI syntax use Dagger to bring software engineering practices (testing, modularity, type safety) to their build pipelines.

How it saves time or tokens

YAML-based CI systems (GitHub Actions, GitLab CI, Jenkins) are hard to test locally and impossible to debug without pushing to the CI server. Dagger pipelines run identically on your laptop and in CI, eliminating the push-and-pray debugging cycle. The built-in content-addressed cache means unchanged steps are skipped on subsequent runs.

Dagger functions are composable and shareable. Instead of copying YAML snippets between repositories, you publish reusable functions that other teams import with type-checked interfaces.

How to use

1. Install the Dagger CLI:

curl -fsSL https://dl.dagger.io/dagger/install.sh | sh

1. Run a function from a module:

dagger -m github.com/dagger/dagger/dev/go call build --source=.

1. Or use the Python SDK:

import dagger
import anyio

async def main():
    async with dagger.Connection() as client:
        out = await (
            client.container()
            .from_('python:3.12')
            .with_exec(['python', '-c', 'print("hello")'])
            .stdout()
        )
        print(out)

anyio.run(main)

Example

A Dagger pipeline that builds and tests a Go project:

import dagger
import anyio

async def ci():
    async with dagger.Connection() as client:
        src = client.host().directory('.')
        golang = (
            client.container()
            .from_('golang:1.22')
            .with_directory('/app', src)
            .with_workdir('/app')
        )
        await golang.with_exec(['go', 'test', './...']).stdout()
        await golang.with_exec(['go', 'build', '-o', 'app']).stdout()

anyio.run(ci)

Related on TokRepo

• DevOps Tools -- Infrastructure and deployment automation tools
• Automation Tools -- CI/CD and build pipeline tools

Common pitfalls

• Dagger requires a running Docker daemon. Rootless Docker works but needs explicit configuration for the Dagger engine socket.
• First-run cold cache is slow because every container layer must be pulled. Subsequent runs with the same dependencies are fast due to content-addressed caching.
• SDK version mismatches between the CLI and language SDK cause cryptic errors. Pin both to the same version in your project.