The emergence of Pulumi CrossCode represents a fundamental shift in the architectural approach to Infrastructure as Code (IaC) and policy as code. Introduced by Pulumi during the second annual PulumiUP conference on May 4th, 2022, CrossCode serves as the universal translation layer that powers the Pulumi infrastructure engine. By decoupling the authoring language from the execution engine, CrossCode eliminates the restrictive boundaries that previously forced cloud builders to adhere to specific domain-specific languages (DSLs) or a limited set of general-purpose programming languages. This technology allows developers and infrastructure experts to utilize any popular programming language to tap into the power of any cloud provider, effectively universalizing the process of provisioning and managing cloud resources.
At its core, CrossCode is not merely a converter but a translation technology that allows for universal authoring. It enables the translation of various cloud formats into any supported Pulumi language, ensuring that the transition from legacy systems or competing IaC frameworks is seamless. This architectural decision allows Pulumi to support a massive array of languages, including the Java Virtual Machine (JVM) ecosystem, .NET, Node.js, Go, Python, and YAML. By implementing this universal translation layer, Pulumi has effectively removed the friction associated with language barriers in cloud engineering, allowing organizations to leverage their existing talent pool without requiring them to learn new, proprietary configuration languages.
The Architecture of the Universal Translation Layer
Pulumi CrossCode functions as the critical intermediary between the user's chosen programming language and the Pulumi infrastructure as code engine. This layer is what enables the platform to provide a universal authoring experience. Without this translation technology, the engine would be limited to the native capabilities of its primary codebase.
The primary function of CrossCode is to convert existing infrastructure as code formats into any supported Pulumi language. This capability is not limited to simple text replacement but involves a sophisticated translation of the intent and structure of the infrastructure definition. The formats that CrossCode can convert include:
- Terraform
- CloudFormation
- Azure Resource Manager
- Kubernetes configuration
The impact of this capability is substantial for enterprises. Organizations that have spent years building their infrastructure in Terraform or CloudFormation are no longer locked into those specific ecosystems. They can translate their existing infrastructure definitions into a general-purpose language like Java or Python, thereby gaining the full power of software engineering practices—such as loops, conditionals, and abstraction—without having to rewrite their entire cloud footprint from scratch.
Furthermore, CrossCode does not operate in a vacuum. It interoperates with all existing infrastructure that has been provisioned by any means. This includes infrastructure managed by other IaC systems or manually provisioned resources. This interoperability ensures that the transition to Pulumi does not require a "rip and replace" strategy, but rather a gradual migration where the new and old systems coexist until the migration is complete.
Expansion of Language Support and the JVM Ecosystem
The introduction of CrossCode was the primary catalyst that enabled Pulumi to broaden its language support significantly. Prior to the implementation of this translation layer, Pulumi supported .NET (including C#, F#, and PowerShell), Node.js (JavaScript and TypeScript), Go, and Python. With CrossCode, the platform expanded to include YAML and the entire Java Virtual Machine (JVM) ecosystem.
The addition of Java is particularly impactful. Java is utilized by more than 35% of developers according to the 2021 StackOverflow Developer Survey. By supporting Java, Pulumi opens its platform to millions of developers who are already proficient in the JVM ecosystem. This support extends beyond the Java language itself to include other JVM languages such as:
- Scala
- Clojure
- Groovy
- Kotlin
The development of this JVM support was bolstered by the expertise of VirtusLab, which applied its deep knowledge of the JVM ecosystem to help bring these capabilities to the Pulumi open source project and eventually into the mainline product. This ensures that the Java implementation is not a secondary thought but a first-class citizen within the Pulumi ecosystem.
In addition to the JVM languages, Pulumi introduced support for YAML. While many developers prefer general-purpose languages, YAML provides a simple, declarative format. This is critical for simple use-cases and improved toolability, allowing users to produce or consume infrastructure as code in a format that is widely understood and easily parsed by other tools, while still tapping into the full capabilities of the Pulumi platform.
Integration with the Pulumi Cloud Engineering Platform
CrossCode is not a standalone utility but is deeply integrated into the broader Pulumi Cloud Engineering Platform. This integration ensures that regardless of the language used for authoring—whether it is a JVM language, a .NET language, or YAML—the user has access to a comprehensive suite of engineering tools.
The components of the platform that integrate with the CrossCode-enabled language support include:
- Reusable multi-language components
- Secrets management
- CI/CD integrations
- Policy as code
- The Pulumi Registry
The real-world consequence of this integration is the standardization of the deployment pipeline. A developer using Java and an infrastructure engineer using TypeScript can both utilize the same Pulumi Registry to discover components and the same secrets management system to secure their credentials. This convergence creates a unified workflow where the language is simply a preference rather than a constraint.
Policy as Code and CrossGuard
One of the most powerful applications of the CrossCode translation layer is its integration with Pulumi CrossGuard. CrossGuard is the policy as code platform that allows organizations to monitor and enforce compliance and security requirements.
Because CrossCode provides a universal translation layer, CrossGuard can monitor and enforce the same compliance packs across all supported languages. This means a single set of controls can be declared and then consistently enforced regardless of whether the infrastructure is being defined in Python, Java, JavaScript, or any other supported language.
The impact of this architecture is two-fold:
- Consistency: Organizations can ensure that a security requirement (e.g., "all S3 buckets must be encrypted") is enforced globally, without having to write separate policy checks for every language used by different teams.
- Efficiency: Changes to a universal compliance service are automatically propagated across all languages. This allows the security team to update a requirement in one place and have it instantly apply to all builds, regardless of the source language.
This capability allows for the declaration of specific requirements that must be met for an application to build successfully, creating a programmatic guardrail that prevents non-compliant infrastructure from ever reaching production.
Philosophical and Technical Origins
The development of CrossCode was driven by the vision of Pulumi's leadership, including co-founder and CEO Joe Duffy, executive chairman Eric Rudder, and CTO Luke Hoban. The goal was to provide infrastructure teams, developers, and security engineers with a true software engineering process for delivering cloud applications.
The technical inspiration for CrossCode draws from experience with the Common Language Runtime (CLR) and the Component Object Model (COM). Joe Duffy noted that the key idea of CrossCode is similar to COM, though applied to a different context. This approach allows Pulumi to build a multi-language runtime where the underlying engine remains consistent while the surface area is expanded to accommodate any language.
The evolution of this technology took several years. While Pulumi initially focused on JavaScript, the company recognized the need for a multi-language runtime. Approximately two years prior to the official announcement, Pulumi began working in earnest on CrossCode, iterating on the technology with key customers to refine its shape and functionality. This iterative process ensured that when CrossCode was launched, it could handle the complexities of real-world infrastructure translation.
Comparative Analysis of IaC Approaches
The introduction of CrossCode positions Pulumi in a unique space compared to other Infrastructure as Code tools. Traditional tools often require the use of a Domain-Specific Language (DSL), which creates a steep learning curve and limits the ability to use standard software engineering tools.
The following table compares the Pulumi approach (powered by CrossCode) against traditional DSL-based tools:
| Feature | Traditional IaC (e.g., Terraform HCL) | Pulumi (with CrossCode) |
|---|---|---|
| Language Type | Domain-Specific Language (DSL) | General-Purpose Languages (JVM, .NET, etc.) |
| Learning Curve | High (Must learn new language) | Low (Use existing language proficiency) |
| Translation | Limited/Manual | Universal via CrossCode |
| Policy Enforcement | Often separate or language-specific | Universal via CrossGuard |
| Tooling | Limited to DSL-specific tools | Full IDE and software engineering ecosystem |
| Interoperability | Often locked to the tool's state | Interoperates with any provisioned infrastructure |
By utilizing CrossCode, Pulumi allows developers to avoid the limitations of HCL (HashiCorp Configuration Language) or the rigidity of YAML, unless YAML is specifically desired for its simplicity. This empowers teams to use native loops, functions, and object-oriented patterns to define their cloud infrastructure, leading to more maintainable and scalable code.
Detailed Technical Summary of Language Capabilities
The current state of Pulumi's language support, enabled by the CrossCode translation layer, is extensive. It allows for the broadest possible reach across the developer landscape.
The following lists detail the specific languages and ecosystems now available:
The JVM Ecosystem
- Java
- Scala
- Clojure
- Groovy
- Kotlin
The .NET Ecosystem
- C
- F
- PowerShell
The Node.js Ecosystem
- JavaScript
- TypeScript
Other General-Purpose Languages
- Go
- Python
Declarative Formats
- YAML
The ability to support these diverse languages is not merely a feature of convenience but a strategic advantage. For instance, a company with a heavy investment in Java for its backend services can now use Java for its infrastructure definitions, ensuring that the same developers who write the application logic can also manage the environment it runs in.
Analysis of Infrastructure as Code Benefits
The universal approach facilitated by CrossCode enhances the core benefits of Infrastructure as Code. IaC is defined as the process of defining the resources needed to deploy an application in code, rather than through manual configuration.
The integration of CrossCode amplifies these advantages:
- Self-Documentation: When infrastructure is defined in a general-purpose language using CrossCode, the code serves as the definitive documentation. Because it uses standard languages, this documentation is accessible to any developer, not just those trained in a specific IaC tool.
- Version Control: All configurations can be stored in Git or other version control systems. This allows for auditing, rollbacks, and peer reviews (Pull Requests) using standard software engineering workflows.
- Repeatability: Deployments can be repeated exactly at any time. This makes it significantly easier to replace a broken installation rather than attempting to fix it manually, which is the cornerstone of immutable infrastructure.
- Scalability: By leveraging the full power of programming languages, developers can create abstractions and components that can be reused across different projects, reducing duplication and increasing consistency.
Conclusion
Pulumi CrossCode is a transformative technology that effectively removes the "language tax" associated with cloud infrastructure. By implementing a universal translation layer, Pulumi has moved beyond the constraints of being a tool that simply supports a few languages to becoming a platform that supports virtually any language the developer chooses. This includes a massive expansion into the JVM ecosystem and the addition of YAML for declarative simplicity.
The impact of CrossCode extends beyond simple authoring; it enables universal policy enforcement through CrossGuard and seamless interoperability with existing infrastructure managed by Terraform, CloudFormation, and other systems. This architectural decision reflects a shift toward treating infrastructure as a first-class software engineering discipline. Instead of forcing users to adapt to the tool, CrossCode adapts the tool to the user.
From a strategic perspective, the integration of CrossCode allows Pulumi to capitalize on the existing skills of millions of developers, particularly those in the Java and .NET ecosystems. By bridging the gap between development and operations through a universal language layer, Pulumi has created a framework where the only limit to cloud infrastructure design is the developer's imagination, not the limitations of a configuration language. The result is a more flexible, scalable, and inclusive approach to cloud engineering that sets a new standard for the industry.