Dagger Engine

80% Faster Build Times

80% Faster Build Times

80% Faster Build Times

Powerful, programmable open source CI/CD engine that runs your pipelines in containers — pre-push on your local machine and/or post-push in CI

Powerful, programmable open source CI/CD engine that runs your pipelines in containers — pre-push on your local machine and/or post-push in CI

Powerful, programmable open source CI/CD engine that runs your pipelines in containers — pre-push on your local machine and/or post-push in CI

No More YAML Soup

Replace complex CI with a programmable platform

Replace complex CI with a programmable platform

Replace complex CI with a programmable platform

Dagger eliminates messy YAML and inconsistent shell scripts by turning your build/test/deploy workflows into reusable, programmable modules, letting your developers run them locally or on any CI provider. Dagger code is far easier to understand, maintain, and optimize.

Dagger automatically generates a DAG to run your pipeline steps concurrently to maximize pipeline speed and accuracy.

Dagger eliminates messy YAML and inconsistent shell scripts by turning your build/test/deploy workflows into reusable, programmable modules, letting your developers run them locally or on any CI provider. Dagger code is far easier to understand, maintain, and optimize.

Dagger automatically generates a DAG to run your pipeline steps concurrently to maximize pipeline speed and accuracy.

Dagger eliminates messy YAML and inconsistent shell scripts by turning your build/test/deploy workflows into reusable, programmable modules, letting your developers run them locally or on any CI provider. Dagger code is far easier to understand, maintain, and optimize.

Dagger automatically generates a DAG to run your pipeline steps concurrently to maximize pipeline speed and accuracy.

  @func()
  async ci(source: Directory): Promise<string> {
    // Use Golang module to configure project
    const goProject = dag.golang().withProject(source)

    // Run Go tests using Golang module
    await goProject.test()

    // Get container with built binaries using Golang module
    const image = await goProject.buildContainer()

    // Push image to a registry using core Dagger API
    const ref = await image.publish("ttl.sh/demoapp:1h")

    // Scan image for vulnerabilities using Trivy module
    return dag.trivy().scanContainer(dag.container().from(ref))
  }
  @func()
  async ci(source: Directory): Promise<string> {
    // Use Golang module to configure project
    const goProject = dag.golang().withProject(source)

    // Run Go tests using Golang module
    await goProject.test()

    // Get container with built binaries using Golang module
    const image = await goProject.buildContainer()

    // Push image to a registry using core Dagger API
    const ref = await image.publish("ttl.sh/demoapp:1h")

    // Scan image for vulnerabilities using Trivy module
    return dag.trivy().scanContainer(dag.container().from(ref))
  }

Locally and in CI

Eliminate Push & Pray

Eliminate Push & Pray

Eliminate Push & Pray

Dagger allows you to build/test/deploy workflows into reusable, programmable modules and lets your developers run them locally (for instant feedback) or on any CI provider (for maximum portability).

A daggerized pipeline run locally or in CI runs the exact same code. As a result, developers can test code locally, identify errors early, and have fewer surprises when pushing to remote repositories.

Dagger allows you to build/test/deploy workflows into reusable, programmable modules and lets your developers run them locally (for instant feedback) or on any CI provider (for maximum portability).

A daggerized pipeline run locally or in CI runs the exact same code. As a result, developers can test code locally, identify errors early, and have fewer surprises when pushing to remote repositories.

Dagger allows you to build/test/deploy workflows into reusable, programmable modules and lets your developers run them locally (for instant feedback) or on any CI provider (for maximum portability).

A daggerized pipeline run locally or in CI runs the exact same code. As a result, developers can test code locally, identify errors early, and have fewer surprises when pushing to remote repositories.

Cached for Speed

75% Lower Costs, 2-5x Performance Boost!

75% Lower Costs, 2-5x Performance Boost!

75% Lower Costs, 2-5x Performance Boost!

Caching accelerates each pipeline run significantly, often cutting run times by over 50%. It not only caches packages but also avoids unnecessary rebuilds and test reruns when nothing has changed, enabling developers to quickly return to coding.

Caching accelerates each pipeline run significantly, often cutting run times by over 50%. It not only caches packages but also avoids unnecessary rebuilds and test reruns when nothing has changed, enabling developers to quickly return to coding.

Caching accelerates each pipeline run significantly, often cutting run times by over 50%. It not only caches packages but also avoids unnecessary rebuilds and test reruns when nothing has changed, enabling developers to quickly return to coding.

func (g *Golang) Base(version string) *Golang {
	mod := dag.CacheVolume("gomodcache")
	build := dag.CacheVolume("gobuildcache")
	image := fmt.Sprintf("golang:%s", version)
	c := dag.Container().
		From(image).
		WithMountedCache("/go/pkg/mod", mod).
		WithMountedCache("/root/.cache/go-build", build)
	g.Ctr = c
	return g

func (g *Golang) Base(version string) *Golang {
	mod := dag.CacheVolume("gomodcache")
	build := dag.CacheVolume("gobuildcache")
	image := fmt.Sprintf("golang:%s", version)
	c := dag.Container().
		From(image).
		WithMountedCache("/go/pkg/mod", mod).
		WithMountedCache("/root/.cache/go-build", build)
	g.Ctr = c
	return g

Multi-Language

import dagger
from dagger import dag, function, object_type

@object_type
class Ci:
    @function
    async def ci(self, source: dagger.Directory) -> str:
        # Use Golang module to configure project
        go_project = dag.golang().with_project(source)

        # Run Go tests using Golang module
        await go_project.test()

        # Get container with built binaries using Golang module
        image = await go_project.build_container()

        # Push image to a registry using core Dagger API
        ref = await image.publish("ttl.sh/demoapp:1h")

        # Scan image for vulnerabilites using Trivy module
        return await dag.trivy().scan_container(dag.container().from_(ref))
import dagger
from dagger import dag, function, object_type

@object_type
class Ci:
    @function
    async def ci(self, source: dagger.Directory) -> str:
        # Use Golang module to configure project
        go_project = dag.golang().with_project(source)

        # Run Go tests using Golang module
        await go_project.test()

        # Get container with built binaries using Golang module
        image = await go_project.build_container()

        # Push image to a registry using core Dagger API
        ref = await image.publish("ttl.sh/demoapp:1h")

        # Scan image for vulnerabilites using Trivy module
        return await dag.trivy().scan_container(dag.container().from_(ref))

Pipelines in the same language as your app

Pipelines in the same language as your app

Pipelines in the same language as your app

Working entirely in a programming language makes it easier to follow best practices for testing and packaging CI pipelines as code.

Because Dagger supports an ever-growing universe of programming languages (incl. Go, Python, JavaScript, and TypeScript) developers can build their pipelines in the language their app is coded in.

Working entirely in a programming language makes it easier to follow best practices for testing and packaging CI pipelines as code.

Because Dagger supports an ever-growing universe of programming languages (incl. Go, Python, JavaScript, and TypeScript) developers can build their pipelines in the language their app is coded in.

Working entirely in a programming language makes it easier to follow best practices for testing and packaging CI pipelines as code.

Because Dagger supports an ever-growing universe of programming languages (incl. Go, Python, JavaScript, and TypeScript) developers can build their pipelines in the language their app is coded in.

Easy to Troubleshoot

Built-in Pipeline Debugging

Since Dagger pipelines are containerized and described as code, rather than long inscrutable YAML, they are much easier to manage. You can now apply software development best practices and troubleshoot them in the same way as any other software.

Dagger provides a powerful in-terminal debugger experience, allowing you to interactively investigate pipeline failures either automatically at the point of failure or via explicit break points. No changes to your pipeline or code is required.

Easy to Troubleshoot

Built-in Pipeline Debugging

Since Dagger pipelines are containerized and defined as code, rather than long inscrutable YAML, they are much easier to manage. You can now apply software development best practices and troubleshoot them in the same way as any other software.

Dagger provides a powerful in-terminal debugger experience, allowing you to interactively investigate pipeline failures either automatically at the point of failure, or via explicit break points.

Since Dagger pipelines are containerized and defined as code, rather than long inscrutable YAML, they are much easier to manage. You can now apply software development best practices and troubleshoot them in the same way as any other software.

Dagger provides a powerful in-terminal debugger experience, allowing you to interactively investigate pipeline failures either automatically at the point of failure, or via explicit break points.

FAQ

What is Dagger Engine?

The Dagger Engine is a powerful, programmable CI/CD engine that runs your pipelines in containers — pre-push on your local machine and/or post-push in your CI. The Dagger Engine is a critical part of the Dagger Platform, which also includes Dagger Cloud and the Dagger SDKs.

What is the Dagger Platform?

What is Dagger Cloud?

What is the Daggerverse?

What are Dagger Modules?

What is Interactive Debugging?

What CIs will Dagger Engine work with?

What language SDKs are available for Dagger?

Is Dagger only for CI/CD? Can it do more?

What are Dagger's caching features?

Get Involved With the community

Discover what our community is doing, and join the conversation on Discord & GitHub to help shape the evolution of Dagger.

Subscribe to our newsletter

Get Involved With the community

Discover what our community is doing, and join the conversation on Discord & GitHub to help shape the evolution of Dagger.

Subscribe to our newsletter

Get Involved With the community

Discover what our community is doing, and join the conversation on Discord & GitHub to help shape the evolution of Dagger.

Subscribe to our newsletter