wasmCloud's deprecated gateway still ships in the default chart
wasmCloud is an open source Cloud Native Computing Foundation (CNCF) project that enables teams to build, manage, and scale polyglot apps across any cloud, K8s, or edge.
At a glance
- What is it?
- wasmCloud is a CNCF incubating platform that runs WebAssembly components as deny-by-default sandboxes, and this monorepo holds the CLI, the embeddable runtime and the Kubernetes operator. The Runtime Gateway has been deprecated since 2.0.3 and is still installed by default, the container build carries a smoke test written to catch rolling base image drift, and both bootstraps fetch from the main branch rather than the tag you installed.
- Who is it for?
- wasmCloud suits a team that wants capability-granted WebAssembly components running under a Kubernetes operator rather than containers, and that is willing to treat the main branch as the source of its scaffolding.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.
Star history
- wasmCloud/wasmCloud2,490 ★ · +46
| Repository | 2026-09-30 | 2026-11-21 |
|---|---|---|
| wasmCloud/wasmCloud | 2.4k | 2.5k |
46 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
A component deprecated in 2.0.3 is still in the default install
The repository table marks one component as retired without removing it. The Runtime Gateway, described as an HTTP gateway that proxies traffic to host pods, is deprecated as of 2.0.3, because routing is now handled by the operator through EndpointSlices on standard Kubernetes Services. The next sentence is the part that matters operationally: the chart still installs the gateway by default for backwards compatibility, and you have to set `gateway.enabled: false` to skip it. So an installation that follows the chart defaults gets a deprecated HTTP proxy in the request path, and the only signal that it is there is the version note in the table. The recommended install command does apply an overlay that disables it, which is why the documented path and the chart default disagree with each other unless you pass that file.
helm install wasmcloud oci://ghcr.io/wasmcloud/charts/runtime-operator \
--namespace wasmcloud --create-namespace \
-f https://raw.githubusercontent.com/wasmCloud/wasmCloud/refs/heads/main/charts/runtime-operator/values.local.yamlBoth bootstraps fetch from the main branch, not the release
Two of the three ways in pull content from a moving reference. The Helm command above takes its values file from a raw content URL whose path contains `refs/heads/main`, so the overlay applied to a chart installed from an OCI registry comes from the branch rather than from the chart version. The same applies to scaffolding a component, where the source is the repository itself plus a subfolder:
wash new https://github.com/wasmCloud/wasmCloud.git \
--subfolder templates/http-hello-world \
--name helloThere is no tag or version argument to either. The consequence is that the project skeleton you generate and the overlay you apply are both tied to whatever `main` holds, while the CLI you run them with is whatever `wash -V` reports. The CLI itself comes from a different set of channels, a shell script fetched over curl on macOS and Linux, a PowerShell one-liner, `brew install wasmcloud/wasmcloud/wash`, `winget install wasmCloud.wash`, or `cargo install --path crates/wash` from a clone, verified with `wash -V`. The container build in this repository checks the same binary with the long `--version` spelling instead.
Nineteen lint rules are denied across the whole workspace
The workspace manifest sets a policy rather than a default. `warnings = 'deny'` under the rust lints, with the comment that all warnings are treated as errors, and `unsafe_code = 'deny'` beside it. Then seventeen clippy rules are denied by name: `unwrap_used`, `expect_used`, `panic`, `indexing_slicing`, `dbg_macro`, `join_absolute_paths`, `needless_collect`, `option_env_unwrap`, `panicking_unwrap`, `serde_api_misuse`, `transmute_ptr_to_ref`, `transmute_undefined_repr`, `trivially_copy_pass_by_ref`, `uninit_vec`, `uninlined_format_args` and `unnecessary_box_returns`. Six more, `unused_extern_crates`, `trivial_numeric_casts`, `unstable_features`, `unused_import_braces`, `unused_lifetimes` and `unused-macro-rules`, are set to warn and annotated as inherited from Wasmtime. The toolchain side is pinned too, with edition 2024, a rust-version floor of 1.95.0 and resolver 3. The workspace also names `crates/wash` as its only default member, which is why building the repository does not drag in the task runner.
The container smoke test exists because two rolling bases drift
The release image ends with a step whose only job is to fail early:
RUN ["/usr/local/bin/wash", "--version"]The comment above it explains why. The builder is `cgr.dev/chainguard/rust:latest-dev` and the runtime base is `cgr.dev/chainguard/wolfi-base`, and both tags roll independently. They can sit on different glibc majors for a window, and the comment names the case it has already happened: the builder on 2.44 while wolfi-base is still on 2.43, which Wolfi ships as separate, mutually conflicting `glibc-2.43` and `glibc-2.44` packages that the package manager cannot reconcile there. Without the check, the image builds green and fails much later as an unreadable `libm.so.6: version GLIBC_x.y not found` in a CrashLoopBackOff inside the operator end to end cluster, far from the build that caused it. The build stage also takes an optional comma separated feature list for opt-in extras such as `wasi-tls` and `wasi-webgpu`, with a note that WASI Preview 3 is already compiled into the default `wash` build and needs no flag.
The Makefile checks that generated CRDs match the chart
The default goal is protobuf generation, and every protobuf step runs inside a container rather than against a local toolchain: `buf generate` for generation, `buf format -w` for formatting and `buf lint` for linting, each as a Docker run that mounts the working directory at `/workspace`. The Kubernetes side has its own set. `kind-setup` creates a local cluster named wasmcloud from a config file in the deploy assets and `kind-nuke` deletes it again. For Helm there are build, render, install and uninstall targets, plus one that is a consistency check rather than an action:
helm-crds-check:
diff --recursive --unified runtime-operator/config/crd/bases charts/runtime-operator/crdsThat target diffs the CRDs the operator generates against the copies committed in the chart, so a change to a custom resource definition cannot reach the chart without the committed copy changing too. The install target uses the same local values file as the documented command, in a namespace called wasmcloud-system with the release named operator-dev, and the uninstall target carries `--ignore-not-found` so it is safe to run twice.
A Go workspace file, two rustfmt spellings, and a set of governance documents
The root of a Rust monorepo carries a few files that do not belong to Rust. There is a `go.work` and a `go.work.sum` at the top level, which is how the Go examples in the tree, local ingress, NATS JetStream replay and the OCI registry example, share a module workspace with the rest of the repository. There are also two spellings of the formatter configuration, `rustfmt.toml` and `.rustfmt.toml`, both at the root, and nothing on the page says which one a given invocation reads. Vulnerability scanning has its own file, `osv-scanner.toml`, and the protobuf toolchain is configured by `buf.yaml` and `buf.gen.yaml`. The process side is unusually well documented for a project of this size: GOVERNANCE.md, MAINTAINERS.md, CONTRIBUTION_LADDER.md, RELEASE_RUNBOOK.md, SECURITY.md, ROADMAP.md, CONTRIBUTING.md and a LICENSE, plus `.github/` for the workflows that the CI badge points at.
The security argument is a default, not a feature list
The case for the platform is made as a comparison of defaults. Containers are described as allow-by-default, with broad access to the network, system calls and environment variables unless something is explicitly blocked, and locking one down is said to require knowing everything it might try to do and then enforcing those restrictions from the outside. WebAssembly components are described as deny-by-default: a component can do nothing, no file I/O, no network access, no system calls, unless a capability is granted. The part that makes this checkable is where capabilities live. They are declared as language-agnostic interfaces in the component itself, which is what keeps the security surface small, visible and auditable, and the runtime enforces them rather than something being bolted on afterwards. wasmCloud's own job is stated as running those components and managing their capabilities, so the choice of which interface a component gets is the platform's decision, not the component author's.
Editorial conclusion
wasmCloud suits a team that wants capability-granted WebAssembly components running under a Kubernetes operator rather than containers, and that is willing to treat the main branch as the source of its scaffolding. Before deploying, check whether the gateway is actually needed in your topology, because the chart installs the deprecated component unless you set gateway.enabled to false, and the overlay that disables it is fetched from the main branch rather than from the release you installed. Read the workspace lint policy before contributing, since nineteen deny rules cover the whole workspace and unwrap, expect, panic and indexing are all refused. And if you build the container, do not drop the version smoke test, because the failure it prevents shows up much later as a CrashLoopBackOff in an end to end cluster.
Frequently asked questions
what is wasmcloud
It is a Cloud Native Computing Foundation incubating project and a cloud native platform for running WebAssembly workloads across any cloud, Kubernetes, datacenter or edge. Workloads are WebAssembly components measured in kilobytes to low megabytes, start in milliseconds and are portable across any conformant WASI runtime.
How do I install the wasmCloud CLI?
Four channels are given: `curl -fsSL https://wasmcloud.com/sh | bash` on macOS and Linux, `iwr -useb https://wasmcloud.com/ps1 | iex` in PowerShell, `brew install wasmcloud/wasmcloud/wash`, and `winget install wasmCloud.wash`. From a clone it is `cargo install --path crates/wash`, and the page verifies the install with `wash -V`.
What is the deprecated Runtime Gateway in wasmCloud?
It was the HTTP gateway that proxied traffic to host pods, and it is deprecated as of 2.0.3 because routing is now handled by the operator through EndpointSlices on standard Kubernetes Services. The Helm chart still installs it by default for backwards compatibility, and setting `gateway.enabled: false` skips it.
What does wash dev do in wasmCloud?
It runs a local development loop powered by wash-runtime, the embeddable Rust runtime that wraps Wasmtime with a plugin-based capability model. The quickstart scaffolds with `wash new` from the repository's templates subfolder, then runs `wash dev` and curls localhost:8000, and it requires the Rust toolchain plus `rustup target add wasm32-wasip2`.
How does wasmCloud control what a component is allowed to do?
Components default to deny by default: no file I/O, no network access and no system calls unless a capability is granted. Capabilities are declared as language-agnostic interfaces inside the component itself, and the runtime enforces them rather than restrictions applied from outside.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/wasmcloud-wasmcloud)Star history chart for your README
[](https://hysenlabs.com/projects/wasmcloud-wasmcloud)Was this useful?