Skip to main content
Version: 1.x

Quickstart

wasmCloud enables you to build polyglot applications out of reusable WebAssembly (Wasm) components and run them everywhere—across any cloud, Kubernetes, datacenter, or edge.

In this tutorial:

  • We'll use the wasmCloud Shell (wash) CLI to build a simple "Hello world" HTTP server application from a WebAssembly component—written in the language of your choice.
  • Along the way, we'll start a developer loop that automatically deploys our application to a local wasmCloud environment.

Install wash​

First, we need to install the latest version of wash.

On macOS, you can use Homebrew to install wash:

shell
brew install wasmcloud/wasmcloud/wash

We support other package managers and the option to install from source. If you'd like to use a different installation method, see the Installation page.

Verify that wash is installed by running:

shell
wash --version

Choose your language​

wasmCloud supports building WebAssembly components from any language that supports the WASI 0.2 target, including Go, Rust, TypeScript, and others.

wash depends on your local language toolchain for your language of choice.

  • Choose the language you would like to use.
  • Install the toolchain or verify that you have the correct versions.

Install the Rust toolchain

Requirements:

You can use the official install script to download rustup, which will automatically install the Rust toolchain:

shell
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Once you've installed the Rust toolchain, use rustup to add the wasm32-wasip2 target:

shell
rustup target add wasm32-wasip2

Create a new component​

Now that we've installed wash and our language toolchain, it's time to create a new component project.

In your terminal, run:

shell
wash new component hello --template-name hello-world-tinygo

After a moment, wash will create a new directory called hello with all of the required project files for building a component from your chosen language.

Navigate to the hello project directory:

sh
cd hello

Start your developer loop​

From our project directory, we'll run:

shell
wash dev

The wash dev command automatically builds your WebAssembly component and deploys it to a local wasmCloud environment. This will take a moment, and the terminal output will update you on the process. The last step should look like this:

text
✅ Successfully started host, logs writing to /home/.wash/dev/kSKCGi/wasmcloud.log
🚧 Building project...
...
✨ HTTP Server: Access your application at http://127.0.0.1:8000
👀 Watching for file changes (press Ctrl+c to stop)...

By default, the application will run on our local port 8000. In a new terminal tab, we can curl our application:

shell
curl localhost:8000

The application should return:

text
Hello from <language>!

You just ran a WebAssembly application in wasmCloud!

Make the application yours​

Now we'll make a change to our code and see how the running application updates automatically.

Modify lib.rs

The Rust code for our component is found in hello/src/lib.rs.

Open the file in your code editor and change the "Hello" message on line 19. You might modify the message to say hello from WebAssembly, your own name, or whatever else you like.

rust
use wasmcloud_component::http;

struct Component;

http::export!(Component);

impl http::Server for Component {
    fn handle(
        _request: http::IncomingRequest,
    ) -> http::Result<http::Response<impl http::OutgoingBody>> {
        Ok(http::Response::new("Hello from Rust!\n")) 
        Ok(http::Response::new("Hello from Wasm!\n")) 
    }
}

Save the modified file. The wash dev automatically builds and deploys the updated component.

In the terminal, curl the application again:

shell
curl localhost:8000
text
Hello from Wasm!

Next steps​

We installed wash, built our first component, and ran our application locally with wash dev.

In our next tutorial, we'll add pluggable, reusable capabilities like key-value storage to our application.