Language Support

wasmCloud runs standard WebAssembly components targeting WASI P2. Any language toolchain that can produce a Wasm component with WASI P2 support can build components that run on wasmCloud.

This page provides a reference for various languages' support for compiling WebAssembly components, as well as wasmCloud ecosystem support for building and running components developed in a given language.

Component Support

This chart summarizes the current state of language support for WebAssembly components, from languages with built-in WASI P2 targets to toolchains that are still in progress.

Language	Toolchain	Status	WASI version
Rust	cargo + wasm32-wasip2 target	Stable	P2
Go	TinyGo	Stable	P2
TypeScript / JavaScript	jco + componentize-js	Stable	P2
C# / .NET	componentize-dotnet	Stable	P2
Python	componentize-py	Stable	P2
C	wasi-sdk + wit-bindgen-c	Stable	P2
C++	wit-bindgen-cpp	Experimental	P2
Ruby	ruby.wasm	In progress	P2 (partial)
Kotlin	Kotlin/Wasm (native)	Planned	—
Swift	SwiftWasm	Roadmap accepted	—
Java	GraalWasm	Planned	—

Tier 1: Well-supported toolchains

These languages are supported by wasmCloud component project templates, wash dev integration, and documentation in the Developer Guide.

Rust

Rust has first-class WebAssembly support via the wasm32-wasip2 compiler target, which ships with the standard Rust toolchain.

• Toolchain: cargo with target wasm32-wasip2 (install via rustup target add wasm32-wasip2)
• Bindings: The wstd crate provides an async Rust standard library for Wasm components and WASI 0.2, hosted by the Bytecode Alliance. You can also use wit-bindgen directly for lower-level control.
• Get started: Developer Guide | Rust Language Guide

JavaScript (TypeScript)

TypeScript components are built using the jco toolchain (part of the Bytecode Alliance), which compiles JS/TS to Wasm components via componentize-js.

• Toolchain: jco + componentize-js
• Bindings: jco generates TypeScript types from WIT files automatically
• Get started: Developer Guide | TypeScript Language Guide

Go (TinyGo)

wasmCloud uses TinyGo (not the standard Go compiler) for WebAssembly component support. TinyGo compiles a large subset of Go to WebAssembly with a much smaller binary footprint.

• Toolchain: TinyGo with -target wasip2
• Bindings: wit-bindgen-go generates Go bindings from WIT files. The go.wasmcloud.dev/component package provides idiomatic Go helpers (e.g. wasihttp.HandleFunc for net/http-style request handling).
• wash support: wash new, wash dev, wash build — requires a .wash/config.yaml configuration file and a Makefile
• Get started: Developer Guide | Go Language Guide

Why TinyGo?

The standard Go compiler does not yet support the Wasm Component Model. TinyGo targets wasip2 directly and produces much smaller binaries, making it the current path for Go developers building Wasm components.

Tier 2: Stable toolchains

These languages have stable Component Model toolchains that can produce components compatible with wasmCloud. You can build components manually and run them with wash, but there are no wash project templates or wash dev integrations yet.

C# / .NET

componentize-dotnet is a Bytecode Alliance project that compiles .NET applications to Wasm components using NativeAOT.

• Toolchain: componentize-dotnet NuGet package
• Status: Stable; actively maintained by the Bytecode Alliance
• Build: Components are built with dotnet build and the componentize-dotnet MSBuild integration
• Repository: bytecodealliance/componentize-dotnet

Python

componentize-py is a Bytecode Alliance project that compiles Python applications to Wasm components.

• Toolchain: componentize-py CLI
• Status: Stable; actively maintained by the Bytecode Alliance
• Build: componentize-py componentize --wit-path wit --world <world-name> -o output.wasm app.py
• Repository: bytecodealliance/componentize-py

Tier 3: In progress or planned

These toolchains are actively working toward Component Model support. Components built with these tools may not yet be fully compatible with wasmCloud.

Language	Toolchain	Status	More information
C	wasi-sdk + wit-bindgen-c	WASI P2 + Component Model support complete	wasi-sdk releases
C++	wit-bindgen-cpp	Experimental	wit-bindgen-cpp repository
Ruby	ruby.wasm	Component Model support in progress	ruby.wasm repository
Kotlin	Kotlin/Wasm	Native Wasm Component Model support planned by JetBrains	JetBrains tracking issue
Swift	SwiftWasm	Component Model roadmap accepted	WebAssembly vision
Java	GraalWasm	WASI support planned	GraalVM documentation

Binding generators

Most languages use wit-bindgen (or a language-specific tool built on the same foundation) to generate typed bindings from WIT interface definitions. wit-bindgen currently supports:

• Rust (wit-bindgen-rust)
• Go (wit-bindgen-go)
• C (wit-bindgen-c)
• C# (via componentize-dotnet)
• Java (wit-bindgen-java, early stage)

For TypeScript/JavaScript, jco handles binding generation as part of its build pipeline.

Further reading

• WebAssembly Component Model specification — Official Component Model repository and specification
• Component Model documentation — Specification and guides for the Wasm Component Model
• WASI.dev — WebAssembly System Interface specifications
• Developer Guide — wash tutorial for creating, building, and publishing components
• Useful WebAssembly Tools — Additional tooling for Wasm development