We're kind of obsessed with reusable building blocks. Our founding team built Docker to help engineers compose complex software out of smaller, reusable parts. But the workflows used to build, test, and deploy them remained manual, complicated, and hard to reuse. So our obsession led us to create Dagger — bringing modularity and reusability to software delivery and development workflows, and turning artisanal processes into modern software factories built from reusable components.

In Dagger, those reusable building blocks are called "modules." You define modules with code and combine them to compose any kind of software delivery workflow, from simple builds to end-to-end tests to AI agents that do code reviews. But the real magic happens when teams can share and reuse one another’s modules, and when platform engineers can standardize and get visibility into the use of those building blocks.

Today we're launching Module Catalog & Insights for Dagger Cloud customers, making it easy for teams to find, reuse, and manage modules privately inside their organization. This lets you fully leverage reusable building blocks to build a modern software factory, and ship great software faster and safer.

How it works: Discover, reuse, and track modules

Just connect your GitHub repos through the Dagger Cloud GitHub app, and your modules automatically pop up in the new Modules tab. Everything is neatly organized in a searchable catalog. Your team won’t waste time reinventing something that already exists — if there's a module out there for what they need, now they can find it.

Each module gets autogenerated API docs in multiple languages, clear metadata, and an activity feed summarizing recent updates. This helps everyone quickly understand what each module does, trust it, and start using it right away.

Traces are directly linked to modules, making it easier to track down issues and see actual usage. See what modules are popular, spot any weird patterns, and find opportunities to improve commonly used components. You also get a clear view of dependencies and dependents, so your team can spot and manage supply-chain risks early.

Example: From one-off workflow to reusable building block

Imagine your engineering team needs to build and ship Golang applications. The platform team creates a standardized, reusable GoApp module that uses a compliant Go version and allows installing additional packages following the company’s best practices:

// Base sets up a pre-configured Golang container ready
// to build and test Go applications
func (m *GoApp) Base(
	source *dagger.Directory, // project source code
) *GoApp { // return standard Go container
	ctr := dag.Container().
		// start with a minimal approved Golang container image
		From("golang:1.24.3-alpine").
		// copy source code directory into the container
		WithDirectory("/app", source).
		// set working directory inside the container
		WithWorkdir("/app").
		// add base pinned required packages
		WithExec([]string{"apk", "add", "git==2.47.2-r0"})
	return &GoApp{Container: ctr}
}

// WithPackage lets you install additional packages that
// must be pinned to a version.
func (m *GoApp) WithPackage(
	ctx context.Context,
	pkg string, // project source code
) *GoApp { // return GoApp type for chaining
	if _, _, ok := strings.Cut(pkg, "=="); !ok {
		panic("cannot install packages without pinned versions")
	}
	m.Container = m.Container.
		WithExec([]string{"apk", "add", pkg}) // install custom package
	return m
}

Once it's pushed to GitHub, the module automatically shows up in your organization's catalog. An engineer working on a new application can discover the module, check the auto-generated docs, and use it to build their application in a few lines:

// Use platform team's base app module as a base Go image with a custom package
// Build fetches the app code from a branch and builds the code
func (m *SomeTeamApplication) Build(ctx context.Context) (string, error) {
    sourceCode := dag.Git(myRepo).Branch("new-feature").Tree()
    return dag.GoApp().Base(sourceCode).
	    WithPackage("zlib-dev"). // platform team owns WithPackage in their module
        Build()
}

As more teams start shipping Golang applications they will discover and use GoApp. The platform team sees the module's usage increasing, invests time to further improve and standardize it, and then uses Module Insights to quickly notify dependent teams about updates. This ensures everyone stays consistent and reliable across the organization.

This is just one basic example. Dagger lets you build modules out of foundational building blocks like containers, directories, custom objects, and even LLMs. You can build anything from simple dev environments to complex, end-to-end workflows powered by AI agents, like automated code reviews and test setups!

Get started today

Module Catalog & Insights are available now in Dagger Cloud for customers on the Team plan. If you’re on the free plan or don’t have an account, you can try Module Catalog & Insights free for 14 days. 

• Sign in to Dagger Cloud and click the new Modules tab.

• Read the docs for Modules and Module Catalog & Insights.

• Join the Discord to ask questions, give feedback, learn from your peers, or talk reusability to us. 

• Explore the Daggerverse to browse nearly 1,500 public modules contributed by the community.