A few days after [launching the public beta of Dagger](https://dagger.io/blog/public-launch-announcement), we asked the community a simple question: [how can we improve our developer experience](https://github.com/dagger/dagger/discussions/2052)? The most popular request was for a [VS Code](https://en.wikipedia.org/wiki/Visual_Studio_Code) extension with proper [Language Server](https://en.wikipedia.org/wiki/Language_Server_Protocol) integration. So we took the community's advice and got to work.

Today, we're happy to introduce the first version of [Dagger for VS Code](https://marketplace.visualstudio.com/items?itemName=Dagger.dagger), bringing a first-class Dagger development experience straight to one of the world's most popular IDE. We're also open-sourcing [our LSP implementation for CUE](https://github.com/dagger/cuelsp), so that every other IDE and text editor can benefit from an improved CUE development experience as well. For example, here is a [guide for adding CUE LSP support to vim](https://github.com/dagger/cuelsp/blob/main/docs/vim.md).

#### Features

For the first release, Dagger for VS Code includes three features: *jump to definition*; *hover*; and *syntax highlighting*. All three features can be used from other IDEs, using the [cuelsp implementation](https://github.com/dagger/cuelsp).

##### Jump to Definition

![Jump to Definition Example](/img/jump-to-def.gif)

Now, we have a simple way to explore the [Dagger Universe](https://universe.dagger.io) and all its definitions. The Dagger Universe is a collection of reusable components, so we can use the “go to definition” feature to pick the one you need quickly.

##### Hover

![Hover Example](/img/hover.gif)

You will need a basic understanding of [CUE definitions](https://cuetorials.com/overview/foundations/#definitions) to get the most out of Dagger. To decrease the learning curve, we have added the ability to show references inline. This provides an easy way to see the overall description of an action and its internal type.

When using “go to definition” and “show definitions”, you will have a complete overview of all CUE definitions used in your Dagger project.

##### Syntax highlighting

We took inspiration from the Golang syntax to create our LSP theme so you can find the essential information quickly.

![lsp theme](/img/lsp-theme.png)

#### What’s an LSP?

A Language Server Protocol (LSP) is a standard used between an editor and a language server to provide language-specific features like auto(completion), go to definition, show references, etc. An LSP is a developer's best friend since it enables an easier way of exploring and understanding code libraries, directly from your code editor:

![LSP Example](/img/buildkit-schema-2-1-.png)

#### The CUE LSP challenge

Creating a CUE language server differs from standard languages like Golang, Python, or C++. In a typical language server, you work directly with the files and interpret them to provide language features.

With CUE, it’s the same, but you also need to work with the CUE engine to compile CUE values to simplify the implementation further.

When creating the Dagger CUE LSP, this constraint added a layer of complexity that we addressed by building a multi-component architecture. We decided to split the responsibility of file loading, jump to definition, hover, etc., into small pieces of code so we can extend it with new features later.

This resulted in the architecture below:

![Dagger CUE LSP Architecture](/img/lip-architecture-1-.png)

#### What’s next?

If you're using VS Code, give [the Dagger extension](https://marketplace.visualstudio.com/items?itemName=Dagger.dagger) a try! If you are using vim, [follow our CUE LSP setup guide](https://github.com/dagger/cuelsp/blob/main/docs/vim.md).

We love hearing from you! To give us feedback, you can [start a discussion](https://github.com/dagger/dagger/discussions), [create an issue](https://github.com/dagger/dagger/issues/new/choose), or [join our Discord server](https://discord.gg/ufnyBtc8uY).


Introducing Dagger for VS Code with CUE LSP support


There’s a running joke in the developer community that the physical supply chain–the one moving goods around the globe– is far more efficient than the software supply chain. And with essentially all computing moving to the cloud, software supply chains are growing in size and complexity. Devops engineers tasked with automating them are under increasing pressure to break through the bottleneck.

My co-founders [Sam Alba](https://twitter.com/sam_alba), [Andrea Luzzardi](https://twitter.com/aluzzardi) and I had seen the same problem time and time again: burned out devops teams trying their hardest to cobble together deployment pipelines that are nearly impossible to scale or port to other cloud platforms. The app deployment experience is painful, and solving this problem is the holy grail of devops.

This is the problem that we aspire to solve with Dagger. Devops engineers using Dagger get a standardized set of building blocks that they can assemble any way they want, knowing that the result will run reliably on any cloud. We’ve been working with some of the best engineers in the world to develop the platform and are [excited to launch the public beta version today](https://dagger.io/blog/public-launch-announcement).

And we’re just getting started. Today, we also announce the closing of a $20 million Series A investment led by Redpoint Ventures, with participation from Y Combinator, Nat Friedman (former CEO, Github), Brian Stevens (former CTO, Google Cloud and former CTO, Red Hat), Idit Levine (founder and CEO, solo.io), Julius Volz (creator of Prometheus), Ellen Pao (former CEO, Reddit), Daniel Lopez (co-founder, Bitnami), and others. Erica Brescia at Redpoint will be an invaluable asset as the newest addition to our board. Erica has been a leader in the devops space for over a decade, as the former co-founder of Bitnami (acquired by VMWare) and former COO of GitHub. We couldn’t imagine a better partner to build an industry-defining platform business.

We would also like to take the opportunity to thank [New Wave](https://newwave.vc), who led our $7 million seed funding round last year. As European founders we are proud to count a European fund as one of our major investors, proof that excellence in venture capital has no borders. Our total funding raised now amounts to $30 million, and we’re thrilled to keep growing our team and developing the Dagger platform with the open source community.

If you or anyone you know wants to join the team building the next stage of the devops revolution, [we would love to chat](https://dagger.io/careers).


Announcing our $20M Series A from Redpoint Ventures


Hi! We’re the creators of Docker, and today we’re proud to introduce our new project, [Dagger](https://dagger.io). Dagger is a portable devkit for CI/CD pipelines. It allows devops engineers to build powerful CI/CD pipelines quickly, then run them anywhere. Benefits include: unifying dev and CI environments; testing and debugging pipelines locally; and avoiding CI lock-in. Most importantly, it introduces an ecosystem of truly composable software components: a “lego system” which we hope will help the devops community solve its fragmentation problem. Under the hood, Dagger is powered by two of the most exciting technologies in the cloud-native ecosystem: [Buildkit](https://github.com/moby/buildkit) and [CUE](https://cuelang.org).

We’ve been developing Dagger together with a community of early adopters. Now we are ready to continue developing it [in the open](https://github.com/dagger/dagger). If you’d like to participate, [join us on Discord!](https://discord.gg/dagger-io).

To our alpha and private beta testers: _thank you_ for investing your time and energy to help us test, review and develop Dagger. We dedicate this launch to you, and we cannot wait to grow this community together.

We’re also hiring! If you’d like to help us improve the lives of devops engineers, [we’d love to talk to you](https://dagger.io/careers).

#### Why Dagger?

##### A developer’s dream is a devops engineer’s nightmare

![engineer automating delivery](/img/cicd-fragmented.png)

There’s never been a better time to be a developer. Thanks to an ever-expanding selection of specialized tools and cloud infrastructure, a dedicated team of developers can ship a competitive product in almost any industry within months. The result is unprecedented growth and innovation at every level of the stack.

This developer’s dream creates a nightmare for devops engineers, whose job is to automate the delivery of increasingly complex applications to increasingly complex cloud infrastructure. In order to continuously build, test and deploy their software, developers need a CI/CD pipeline that glues together an ever-expanding collection of specialized tools. The result is a mess of homemade scripts that are painful to write, difficult to debug and test, and must be rewritten for each new development and CI environment. Component reuse between pipelines is low, which causes fragmentation and a constant reinvention of the wheel.

##### Modernizing the CI/CD development experience

![astronaut writing a plan](/img/unifed-automated-resilient.png)

Dagger solves the devops engineer’s nightmare by telling them: “your pipelines are software. This makes you a developer, and you deserve a proper developer experience”. For example:

- Instead of gluing pipelines together with throwaway scripts, they can “play lego” by composing reusable actions, using an intuitive declarative language and API.
- Actions can safely be shared and reused thanks to a complete package management system, and there is a growing catalog of open-source actions developed by the community.
- Pipelines can be tested and debugged locally, then run on any CI system
- All actions are automatically cached: no manual tweaking necessary

This allows devops engineers to continuously improve their pipelines, with the confidence afforded by modern development practices.

##### Write your pipeline once, run anywhere

![astronaut deploying](/img/write-pipeline-once.png)

Because Dagger runs equally well anywhere a Docker-compatible runtime is available, it eliminates two major problems in the devops experience: dev/CI drift, and CI lock-in.

- _Dev/CI drift_: instead of writing the same automation twice - once in a CI-specific configuration, and again in a Docker compose file, shell script or Makefile - simply write a Dagger plan once, then run it in all environments.
- _CI lock-in_: migrating from one CI system to another, or supporting teams with multiple CI systems, should not require rewriting entire pipelines from scratch! The same Dagger plan can be run without modification on all major CI systems.

#### What’s next?

Dagger is still in the early stages of development. Thanks to a [new round of funding](https://dagger.io/blog/series-a) we will continue to expand our team, and continue building the ultimate CI/CD experience: more portable, more productive… and more fun!

If you share our definition of fun, [come say hi](https://discord.gg/dagger-io)! Our community is open to all, from beginners to seasoned devops veterans. We look forward to building something great together.

Happy hacking!


Introducing Dagger: a new way to create CI/CD pipelines


#### Today we are proud to introduce dagger 0.2, codename Europa.

This is our first major release since the beginning of our private beta last year, and it is based entirely on your feedback.

To all of you who have invested the time to test our nearly 40 releases; to report issues, suggest improvements, contribute and review code and documentation: thank you! This release would not be possible without you.

#### Migrating from 0.1 to 0.2

Please note that, unfortunately, this release is not backwards compatible: plans written for dagger 0.1 will not run on version 0.2. Automatic migration is not supported, but manual migration is relatively straightforward. Going forward, we plan to make backwards compatibility a priority, either by not breaking APIs, or providing seamless migration if we do. If you need help migrating your plan, we will be happy to assist you!

[Learn more about migrating to 0.2](https://docs.dagger.io/1214/migrate-from-dagger-0.1).

#### What's new in dagger 0.2?

This release has one focus: improve the developer experience. It features a redesigned CLI and powerful new APIs.

The result is a completely new way to develop CI/CD pipelines: more productive, more portable… and way more fun!

##### **One simple configuration for everything: the Plan**

We have radically simplified the process of setting up and configuring a pipeline. From having to learn half a dozen different commands and configuration files... to just one step: write the plan.

In Dagger 0.2, every aspect of your pipeline is controlled, declaratively, in your plan. In addition to making Dagger simpler to understand and use, it makes it natively compatible with declarative patterns such as gitops.
[Learn more about the Dagger Plan](https://docs.dagger.io/1202/plan).

##### **Lego for your pipelines: the Action API**

Dagger’s superpower is its lego-like composition model: simple actions can be composed to form a more complex one; which in turn can be composed again; and so on, until even the most complex pipelines can be assembled at a fraction of the usual cost, and at higher quality.

The foundation of this model is the Action API: a complete framework for composing arbitrarily complex automations out of standardized primitives, declaratively, using CUE and Buildkit.
[Learn more about the Action API](https://docs.dagger.io/1213/api).

##### **One simple command: dagger do**

We have simplified the dagger CLI so that anyone can intuitively understand what your pipelines do and how to use them, even if they’ve never used Dagger. No knowledge of CUE required!

Running a pipeline is as simple as _dagger do ACTION_. For example, _dagger do build_, _dagger do test_, _dagger do deploy_. Actions are loaded directly from your plan, so you can declaratively control your pipeline's command-line experience. Best of all, _dagger do --help_ dynamically loads available actions and presents them to the user.

##### **Integrate dagger anywhere: the Client API**

In dagger 0.2, a plan may use the Client API to interact with the client machine in a variety of ways: read or write to the filesystem; access environment variables; open network connections; query platform information; and even execute commands. This allows seamless integrations into your existing tooling and infrastructure.

For example, your development machine may have Docker credentials stored in the MacOS keychain; your CI runner may be configured to request ephemeral tokens for a specific profile before each AWS operation; or you may want to run tests against a local source code checkout. These integrations cannot be sandboxed in a container: they require access to the client machine. The Client API makes them possible in just a few lines of CUE.

[Learn more about the Client API](https://docs.dagger.io/1203/client)

##### **Secure by default: the Secrets API**

Secrets are a crucial part of any CI/CD pipeline, which is why Dagger introduced native support for secrets from the very beginning. Dagger 0.2 expands and improves this feature in several ways:

- Dagger secrets are never merged into the plan, which helps prevent credential leaks. And just in case you accidentally print a secret’s contents in your action logs… Dagger will automatically detect it and scrub it. You’re welcome!
- Using the new Client API, secrets can now be loaded from virtually any source: a file, an environment variable, a proprietary KMS, a vault service, a local keychain, etc.
- Actions can now dynamically create their own secrets, using the [\#NewSecret core action](https://github.com/dagger/dagger/blob/main/pkg/dagger.io/dagger/secrets.cue#L18).
- Actions can now perform common operations against the contents of a secret, securely, without accessing the contents directly (to avoid leaks). Operations include [extracting a secret from a JSON- or YAML-encoded envelope](https://github.com/dagger/dagger/blob/main/pkg/dagger.io/dagger/secrets.cue#L5), and [trimming space characters](https://github.com/dagger/dagger/blob/main/pkg/dagger.io/dagger/secrets.cue#L32).
- Secrets can now be injected into containers as environment variables, in addition to temporary files

[Learn more about the Secrets API](https://docs.dagger.io/1204/secrets)

---

#### Get involved!

Dagger is a community-driven project. We develop in the open, and anyone is welcome to join the fun, no matter how experienced. Whether you’re a seasoned engineer, or looking to make your first open-source contribution, there are many ways you can contribute. Come say hello [on our Discord server](https://dagger.us20.list-manage.com/track/click?u=78ddebf129e125c5037fd6f4d&id=bda77f8e8d&e=174ebdaff6 'https://dagger.us20.list-manage.com/track/click?u=78ddebf129e125c5037fd6f4d&id=bda77f8e8d&e=174ebdaff6')!


💫 Introducing Dagger: a new way to create CI/CD pipelines!

Introducing Dagger for VS Code with CUE LSP support

Announcing our $20M Series A from Redpoint Ventures

Introducing Dagger: a new way to create CI/CD pipelines

Europa Rising: Introducing Dagger 0.2