DEV Community: Andrzej Ressel

Pulumi Gestalt 0.0.3 released

Andrzej Ressel — Tue, 17 Jun 2025 00:00:00 +0000

This is the third release of Pulumi Gestalt, a universal runtime for Pulumi.

Schema

Pulumi schemas have traditionally been stored in YAML files, but the complexity of their content often leads to a lot of boilerplate when mapping into domain objects. In Pulumi Gestalt 0.0.3, both the Rust and C FFI targets (Wasm coming later) now support obtaining schemas as native Rust structs or serialized Protobuf messages for C.

The Protobuf schema is designed to be straightforward—no additional mapping logic required. Check documentation for more info:

Give Pulumi Gestalt 0.0.3 a try and let me know what you think!

Pulumi Gestalt 0.0.2 released

Andrzej Ressel — Sun, 06 Apr 2025 04:00:00 +0000

This is the second release of Pulumi Gestalt, a universal runtime for Pulumi.

Wasm Cleanup

I've cleaned up the Wasm WIT files quite a bit. Before, there were two files and four worlds—now, it's down to a single file and a single world.

Config API

This version introduces a new get_config function, which lets users retrieve configuration values. It works with both plaintext values and secrets.

Documentation Improvements

I also made some updates to the documentation. There's now a new Rust example aimed at language implementers who want to use Rust, and I rewrote the old C++ example in pure C.

What's Next?

For the next version, I'm hoping to add a Schema API to make code generation easier.

Give Pulumi Gestalt 0.0.2 a try and let me know what you think!

Pulumi Gestalt 0.0.1 released

Andrzej Ressel — Mon, 10 Mar 2025 10:00:00 +0000

After a year of work and multiple DevLogs, the first public release of Pulumi Gestalt is now available!

What is Pulumi Gestalt?

Historically, adding a new language to Pulumi has been a significant challenge—requiring integration with the gRPC API, proper serialization, schema.json processing, and creating callback infrastructure.

Pulumi Gestalt aims to change that. Currently it provides a set of ten functions that allow developers to add basic Pulumi support for any language that supports:

C FFI
Rust (for languages such as Erlang or Dart)
Wasm

Currently, Pulumi Gestalt allows:

Resource creation and invocation
Output mapping

Rust Support

Beyond general language integration, Pulumi Gestalt includes comprehensive support for Rust. Key features include:

Automatic glue code generation on the user side
Filtering support for large providers (e.g., cloud providers that require 20GB+ RAM for compilation without filters)
Example code generation (currently in early alpha)

What’s Next?

Pulumi Gestalt is just getting started. Upcoming features include:

A schema.json converter for easier ingestion (likely supporting Avro and Protobuf)
Configuration support
Automation API integration

This initial release provides a strong foundation for expanding Pulumi support across more languages.

Documentation & Examples

Full documentation: Pulumi Gestalt Docs
Rust examples: GitHub Repository

Pulumi Gestalt devlog #8

Andrzej Ressel — Sun, 16 Feb 2025 19:30:16 +0000

Welcome to the eighth devlog for Pulumi Gestalt. This week, the focus was on preparing native Rust support and moving toward an initial release.

Native Rust Support

Previously, Rust support in Pulumi Gestalt was essentially Wasm/Rust support, which required a complex setup and runtime environment. This week, I implemented proper native Rust support, which simplifies the process significantly. Now you can get started without external runners - only Rust and Just required.

Initial Release

After several weeks of development and refinement, I believe Pulumi Gestalt has reached a state where it’s ready for an initial release. Over the next few days, I’ll be focusing on finalizing documentation and ensuring consistent naming conventions across the SDKs to provide a smoother experience for users.

That’s all for this week’s updates! As always, I welcome your feedback. If you have any thoughts, suggestions, or run into issues, feel free to share them on either the main repository or the example repository.

Pulumi W̶a̶s̶m̶/̶R̶u̶s̶t̶ Gestalt devlog #7

Andrzej Ressel — Sun, 09 Feb 2025 18:27:01 +0000

Welcome to the seventh devlog for Pulumi ~~Wasm/Rust~~ Gestalt. This week was all about rerelease and preparation for native Rust support.

Rerelease

The project has been renamed to Pulumi Gestalt. The new name reflects the broader vision of the project—to provide simple interfaces for other programming languages to add support for Pulumi. While not all documentation pages have been updated yet, the GitHub and Cloudsmith repositories have been renamed:

Main repository: https://github.com/andrzejressel/pulumi-gestalt
Examples repository: https://github.com/andrzejressel/pulumi-gestalt-example
Releases repository: https://github.com/andrzejressel/pulumi-gestalt-releases
Docs: https://andrzejressel.github.io/pulumi-gestalt/

Native Rust support

Currently, Pulumi Gestalt supports C and Wasm/Rust. Next week, I'll be working on native Rust support, which will also pave the way for other languages like Dart and Erlang.

That’s all for this week’s updates! As always, feedback is welcome — let me know your thoughts or if you run into any issues on either main repository or example repository

Pulumi Wasm/Rust devlog #6

Andrzej Ressel — Sat, 01 Feb 2025 18:23:27 +0000

Welcome to the sixth devlog for the Wasm/Rust support for Pulumi! This week and the next are all about the project's rerelease under a new name and C FFI support. Let’s dive into the updates!

C FFI Support

I’m excited to share that the project is being extended to support C FFI (Foreign Function Interface)! This opens up new possibilities for integrating additional languages into the Pulumi ecosystem. While the C FFI support is still in its early stages and not fully documented, I encourage all experimenters to give it a try and share your feedback.

Prebuilt Library: You can find the prebuilt library in the releases section.
Example C++ Project: To help you get started, I’ve added an example C++ project in the main repository. This should serve as a useful reference for integrating the library with other languages.

That’s all for this week’s updates! As always, feedback is welcome — let me know your thoughts or if you run into any issues on either main repository or example repository

Pulumi Wasm/Rust devlog #5

Andrzej Ressel — Sun, 26 Jan 2025 18:14:50 +0000

Welcome to the fifth devlog for the Wasm/Rust support for Pulumi! This week, I focused on three key areas: project renaming, implementing support for secrets, and introducing a context parameter as preparation for C FFI integration.

Project Renaming

The project has been renamed from Pulumi WASM to Pulumi Wasm. This change is mostly cosmetic and limited to documentation updates—there were no changes to the actual codebase.

Secrets

Pulumi Wasm now supports secrets! 🎉 This brings new functionality to the project:

A new Output constructor, Output::new_secret, has been added to handle secrets.
Resources that return secrets (like those in the random provider) are now correctly processed.
Mapping and combining functions have also been updated to respect secrets:
- A mapped secret Output remains secret.
- When combining outputs, if any of the inputs are secret, the resulting output is also marked as secret.

Context Parameter

To prepare for future C FFI integration, the implicit global Pulumi value has been removed. Instead, most functions now require a PulumiContext object. This change affects several core areas of the library, including:

Output constructors
Formatting
Resource creation
Function invocation

Additionally, the pulumi_main macro has been reworked. Previously, it was a procedural macro applied directly to the main function:

use anyhow::Result;  
use pulumi_wasm_rust::pulumi_main;  

#[pulumi_main]  
fn main() -> Result<()> {  
}

Now, it is a declarative macro that expects a pulumi_main(PulumiContext) function defined at the same level:

use anyhow::Result;  
use pulumi_wasm_rust::{pulumi_main, PulumiContext};  

pulumi_main!();  

fn pulumi_main(context: &PulumiContext) -> Result<()> {  
}

That’s all for this week’s updates! As always, feedback is welcome — let me know your thoughts or if you run into any issues on either main repository or example repository

Pulumi Wasm/Rust devlog #4

Andrzej Ressel — Sun, 19 Jan 2025 22:38:22 +0000

Welcome to the fourth devlog for the Wasm/Rust support for Pulumi! This week, I focused on improving provider versioning and spent time exploring the long-term vision for the project. Here’s what’s new:

Provider Version Support

Until now, we hadn’t set the proper provider version when calling Pulumi. While this didn’t throw an error, it caused the newest installed provider to be used by default. Since providers can introduce incompatible changes between versions, this behavior could lead to subtle bugs.

This issue has now been resolved. The provider glue code generated for version X will now explicitly request version X from Pulumi during execution, ensuring compatibility and reducing the risk of unexpected errors.

Future of the Project

This week, I spent a lot of time reflecting on the future direction of this project. (In fact, I created a few tickets to explore this further).

While WASM is an exciting target and has allowed me to design a constrained Pulumi execution engine, I’m now considering expanding the scope to include a native library. My goal is to create something akin to Amazon’s CRT—a library that supports both languages with C FFI and WASM-only languages. This approach would allow the project to serve a broader range of use cases and developers.

That's all for this week's updates!. As always, feedback is welcome—let me know your thoughts or if you run into any issues!

Pulumi Wasm/Rust devlog #3

Andrzej Ressel — Mon, 13 Jan 2025 20:24:01 +0000

Welcome to the third devlog for the Wasm/Rust support for Pulumi! This week, I focused on improving the versioning and release process, along with adding a new format!-like macro. Here's what's new:

Versioning

Previously, every version used the format 0.0.0-NIGHTLY-COMMITSHA. The main issue was that users did not know when a library version was released, making it difficult to check for updates.

To solve this, I've switched to calver. For example, today's release would be v25.1.12-47a9821.

This ensures users can quickly identify the release date of a version, making it easier to stay up to date.

Release Spam

Pulumi and binstall require a GitHub release for every deployed version. Currently, I deploy a new version after every commit to the main branch, which creates notification spam for users who star the repository.

To resolve this, I've created a separate repository just for releases: pulumi-wasm-releases. This keeps the main repository cleaner while ensuring users can still access the latest versions.

Additionally, the commands for downloading binaries have changed due to the separate release repository. Be sure to check the example repository for updated instructions.

Format Macro

The latest version of the library introduces the pulumi_format! macro. It works like Rust's format! macro but is designed specifically for Pulumi's Output types.

A key feature is that not all arguments need to be of type Output—you can seamlessly combine Output values with regular values.

For example:

let a = Output::new(&1);
let b = Output::new(&"test".to_string());
let formatted: Output<String> = pulumi_format!("{} {}", a, b); // "1 test"

Replacement of combineX function with pulumi_combine! macro

Previously, there were multiple combineX methods for combining Outputs. These have now been replaced with a single pulumi_combine! macro for greater flexibility and simplicity. This change reduces redundancy and makes the API more intuitive.

For example:

let a = Output::new(&1);
let b = Output::new(&"test");
let combined: Output<(i32, &str)> = pulumi_combine!(a, b);

That's all for this week's updates!. As always, feedback is welcome—let me know your thoughts or if you run into any issues!

Pulumi Wasm/Rust devlog #2

Andrzej Ressel — Sun, 05 Jan 2025 17:44:26 +0000

Welcome to the second devlog for the Wasm/Rust support for Pulumi! This week, I focused on key improvements related to module generation, cloud provider support, and CI optimization. Here's what's new:

Module filtering

Compiling large cloud providers like AWS can be time-consuming and resource-intensive. For example, building the entire AWS provider can take over 10 minutes and use 10GB of RAM. This is often unnecessary since most users only need specific functionality.

To address this, I’ve added module filtering support. Now, you can use the new generate_with_filter function to generate only the modules you need.

Example Use Case

If your project only uses AWS S3, you can specify just the s3 module to dramatically reduce compilation time and memory usage.

generate_with_filter("aws", "6.66.2", &["s3"]);

This feature saves time and reduces resource usage, and improves efficiency during development.

AWS/Azure/GCP Classic

I’m excited to announce that the three largest cloud providers — AWS, Azure, and GCP — are now officially supported and tested. A subset of their APIs is available for preview in the documentation:

When using these providers, I recommend using the module filtering mentioned earlier to customize your build to include only what you need.

CI

To ensure stability and reliability, I’ve made significant improvements to the CI pipeline. Previously, all integration tests ran in a single CI job, which slowed feedback. Now, each provider is tested in its own dedicated job which reduces CI time significantly.

Thank you for following along with this journey! If you’re interested in contributing or trying it out, check out the main and example repositories for more details. Your feedback is invaluable — feel free to open an issue or share your thoughts!

Pulumi Wasm/Rust devlog #1

Andrzej Ressel — Sun, 29 Dec 2024 00:30:05 +0000

Since my last post more than half a year have passed. The project is still going strong and a lot of improvements have been introduced.

Builders

Last time, all fields were required (even is they are empty):

    let random_string_1 = random_string(
        "test_1",
        RandomStringArgs {
            keepers: None.into(),
            length,
            lower: None.into(),
            min_lower: None.into(),
            min_numeric: None.into(),
            min_special: None.into(),
            min_upper: None.into(),
            number: None.into(),
            numeric: None.into(),
            override_special: None.into(),
            special: None.into(),
            upper: None.into(),
        },
    );

I've migrated all the structs to bon so now they look like this

    let random_string_1 = random_string::create(
        "test_1",
        RandomStringArgs::builder().length(length).build_struct(),
    );

In the future I will experiment with Function Builder to see if it will be a better choice

Code generation

Last time provider was split into two parts - Wasm based provider (generated on Pulumi WASM side and distributed as binary artifact) and glue code (potentially generated on user side, last time still generated by Pulumi Wasm).

I've decided to go 100% for code generation on user side. Thanks to that user can use any provider they want in any version they want. In addition provider does not have to be available in public Pulumi registry - glue code can be generated from schema.json.

# build.rs
use std::error::Error;
fn main() -> Result<(), Box<dyn Error>> {
    pulumi_wasm_build::generate("random", "4.15.0")?;
    Ok(())
}

Examples

Currently Pulumi does not export code examples in easy to ingest format. I've decided to try reading YAML and the results are pretty good - for now it's very basic and things like variables, interpolation and complicated order does not work. Here is example of ACMPCA Permission

use pulumi_wasm_rust::Output;
use pulumi_wasm_rust::{add_export, pulumi_main};
#[pulumi_main]
fn test_main() -> Result<(), Error> {
    let example = permission::create(
        "example",
        PermissionArgs::builder()
            .actions(vec!["IssueCertificate", "GetCertificate", "ListPermissions",])
            .certificate_authority_arn("${exampleCertificateAuthority. arn}")
            .principal("acm.amazonaws.com")
            .build_struct(),
    );
    let exampleCertificateAuthority = certificate_authority::create(
        "exampleCertificateAuthority",
        CertificateAuthorityArgs::builder()
            .certificate_authority_configuration(
                CertificateAuthorityCertificateAuthorityConfiguration::builder()
                    .keyAlgorithm("RSA_4096")
                    .signingAlgorithm("SHA512WITHRSA")
                    .subject(
                        CertificateAuthorityCertificateAuthorityConfigurationSubject::builder()
                            .commonName("example. com")
                            .build_struct(),
                    )
                    .build_struct(),
            )
            .build_struct(),
    );
}

There are still a lot of things to do - generating the biggest providers (AWS almost works), core improvements (there are non-working edge cases,
like functions without inputs), example generation improvements, documentation and creating PoC of non-rust WASM language.

Links:
Main repository: https://github.com/andrzejressel/pulumi-wasm
Example: https://github.com/andrzejressel/pulumi-wasm-example

Experimental Wasm/Rust support for Pulumi

Andrzej Ressel — Thu, 15 Aug 2024 21:55:25 +0000

I was working on this for the last few months and while it's still not very ergonomic I believe it's usable enough to write post about it.

What is Pulumi

Pulumi as basically Terraform, but you write code in your favourite programming language. Officially it supports Go, Python, Typescript, C# and Java (kinda). There is also community support for Kotlin and Scala

Why WASM

I'm mostly interested in interopability of Wasm and WASI's Component Model. Thanks to component model I can generate WASM module with core logic and others can develop bindings for it in their own language. While currently not many languages support binding generation, I believe with growing popularity of WASM this will change.

Current state

The project is still in pretty rough state. The basic basics works - creating resources, mapping elements (even unknown ones) and passing them works, but it's pretty much it. There are some manual steps that must be made before running the code, versioning is very strict and not much of the pulumi features are implemented (for now only creating resources - nothing more).

I'm currently planning on focusing on UX first and on additional Pulumi features later.

Example code

Here is program that will generate two random strings, where the length of the second one is based on the first one - it's mostly to illustrate that the most interesting thing about Pulumi (arbitrary code execution on generated values) works.

use anyhow::Error;
use pulumi_wasm_random::resource::random_string::{random_string, RandomStringArgs};
use pulumi_wasm_rust::Output;
use pulumi_wasm_rust::{add_export, pulumi_main};

#[pulumi_main]
fn test_main() -> Result<(), Error> {
    let length: Output<i32> = Output::new(&4);
    let random_string_1 = random_string(
        "test_1",
        RandomStringArgs {
            keepers: None.into(),
            length,
            lower: None.into(),
            min_lower: None.into(),
            min_numeric: None.into(),
            min_special: None.into(),
            min_upper: None.into(),
            number: None.into(),
            numeric: None.into(),
            override_special: None.into(),
            special: None.into(),
            upper: None.into(),
        },
    );

    let new_length = random_string_1.result.map(|s| s.len() as i32);

    let random_string_2 = random_string(
        "test_2",
        RandomStringArgs {
            keepers: None.into(),
            length: new_length,
            lower: None.into(),
            min_lower: None.into(),
            min_numeric: None.into(),
            min_special: None.into(),
            min_upper: None.into(),
            number: None.into(),
            numeric: None.into(),
            override_special: None.into(),
            special: None.into(),
            upper: None.into(),
        },
    );

    add_export("result", &random_string_1.result);
    add_export("number_1", &random_string_1.length);
    add_export("number_2", &random_string_2.length);
    Ok(())
}

Repositories

Quick start example that uses Pulumi Random provider: https://github.com/andrzejressel/pulumi-wasm-example

The main repository is located here: https://github.com/andrzejressel/pulumi-wasm

Rustdocs for supported providers (cloudflare, docker and random) are available here: https://andrzejressel.github.io/pulumi-wasm/rust-docs/pulumi_wasm_rust/index.html

DEV Community: ​Andrzej Ressel

Pulumi Gestalt 0.0.3 released

Schema

Pulumi Gestalt 0.0.2 released

Wasm Cleanup

Config API

Documentation Improvements

What's Next?

Pulumi Gestalt 0.0.1 released

What is Pulumi Gestalt?

Rust Support

What’s Next?

Documentation & Examples

Pulumi Gestalt devlog #8

Native Rust Support

Initial Release

Pulumi W̶a̶s̶m̶/̶R̶u̶s̶t̶ Gestalt devlog #7

Rerelease

Native Rust support

Pulumi Wasm/Rust devlog #6

C FFI Support

Pulumi Wasm/Rust devlog #5

Project Renaming

Secrets

Context Parameter

Pulumi Wasm/Rust devlog #4

Provider Version Support

Future of the Project

Pulumi Wasm/Rust devlog #3

Versioning

Release Spam

Format Macro

Replacement of combineX function with pulumi_combine! macro

Pulumi Wasm/Rust devlog #2

Module filtering

Example Use Case

AWS/Azure/GCP Classic

CI

Pulumi Wasm/Rust devlog #1

Builders

Code generation

Examples

Experimental Wasm/Rust support for Pulumi

What is Pulumi

Why WASM

Current state

Example code

Repositories

DEV Community: Andrzej Ressel