Dagger Engine
Dagger Engine
Dagger Engine
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
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
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
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
var goProject = dag.golang().withProject(source)
// Run Go tests using Golang module
await goProject.test()
// Get container with built binaries using Golang module
var image = await goProject.buildContainer()
// Push image to a registry using core Dagger API
var 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
var goProject = dag.golang().withProject(source)
// Run Go tests using Golang module
await goProject.test()
// Get container with built binaries using Golang module
var image = await goProject.buildContainer()
// Push image to a registry using core Dagger API
var 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.
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 CIs will Dagger Engine work with?
What are Dagger's caching features?
What is Distributed Caching?
What language SDKs are available for Dagger?
