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.
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?
