WebAssembly Outside the Browser - What the Host Grants, Where the Sandbox Ends, and Who Runs the Host

First Published:
Last Updated:

WebAssembly (Wasm) can run outside the browser. An increasing number of products are running Wasm modules and components on application plugins, edge servers, and Kubernetes nodes. But does placing code in Wasm guarantee its security? Where does the execution environment reside, who controls it, and who fixes vulnerabilities?

This article examines Wasm outside the browser, not as a list of runtime features, but through three key considerations. First, what capabilities does the host provide to the Wasm code? Second, where do the boundaries of isolation end? And third, who operates and updates the host? This article checks these three aspects in four places: in-process plugins, edge servers, inside JavaScript hosts, and Kubernetes.

In short, the capabilities of Wasm code are entirely determined by what the host grants. That boundary is implemented by the host's code. WASI currently has three versions (0.1, 0.2, and 0.3), each with a different way of granting access. Some Wasm hosts do not follow WASI. Defects in the boundary can only be fixed through updates to the runtime. The timing and availability of those updates depend on the runtime's support policies and whether the host operator chooses to upgrade the version.

This article is based on materials reviewed on November 20, 2026 (Japan Standard Time). WASI and runtime versions are constantly evolving on a monthly basis. The dates of verification are noted in the tables. This article does not cover pricing, performance comparisons, or rankings of products.

Related articles on this site:

Table of Contents

  1. 1. Scope and Terms
  2. 2. Target Versions
  3. 3. What the Host Grants
  4. 4. Where the Host Runs
  5. 5. Where Isolation Boundaries End
  6. 6. Who Keeps the Host Patched
  7. 7. Toolchain Readiness and Failure Modes
  8. 8. A Decision Table
  9. 9. Frequently Asked Questions About WebAssembly Outside the Browser
  10. 10. Summary
  11. 11. References

1. Scope and Terms

This chapter defines the scope of this article, its intended audience, the materials consulted, and key terminology. The following ten points summarize the conclusions.

  • WASI currently has three versions: 0.1, 0.2, and 0.3. The releases page describes version 0.3 as Stable, current, version 0.2 as Stable, superseded by 0.3, and version 0.1 as Legacy (Section 2.1).
  • Regarding WASI 0.3.2, the roadmap page lists it as Planned, while the WASI GitHub releases page shows a version 0.3.2 dated October 13, 2026. This article treats this as Sources disagree (Section 2.2).
  • The W3C's WebAssembly Core page is a Candidate Recommendation Draft with the content of version 3.0. It is not a W3C Recommendation (Section 2.3).
  • The security page states that code running under WASI does not, by default, have access to the outside world. This is WASI's own statement (Section 3.1).
  • The way access is granted varies by version. Version 0.1 uses file descriptors opened at startup, version 0.2 uses WIT imports, and version 0.3 uses the world boundary (Sections 3.2 through 3.4).
  • Some Wasm hosts grant access under rules other than WASI. These include Proxy-Wasm in Envoy and Istio, Helm 4's extism/v1, and the JavaScript host of Cloudflare Workers (Section 3.5 and Chapter 4).
  • The entity responsible for operating the host varies depending on the environment. On edge servers, it is the vendor; for Kubernetes and in-process plugins, it is the user side (Chapter 4).
  • Implementing the isolation boundary is the responsibility of the host's code. A security advisory published by Wasmtime on October 29, 2026, highlights a flaw in the host's permission checks (Section 5.2).
  • Wasmtime releases a major version every month and supports each release whose number is a multiple of 12 for 24 months. This LTS (Long-Term Support) does not guarantee that the API will remain unchanged. Wasm support in Docker Desktop is deprecated (Chapter 6).
  • No statement was found regarding a managed runtime for running Wasm on AWS (No statement found). AWS's official documentation provides a sample for creating custom AMIs on Amazon EKS (Section 6.5).

1.1 Intended Audience

This article is intended for the following audience:

  • Developers seeking ways to run third-party code and plugins within their own applications.
  • Architects and operations personnel considering whether to run WebAssembly (Wasm) workloads on edge servers or Kubernetes.
  • Individuals evaluating Wasm isolation in comparison to containers, microVMs, and V8 isolates.

This article assumes that readers may hold the following views, and checks each of them against the sources:

  • That placing code in Wasm makes that code safe.
  • That WASI has one version, and every toolchain emits the same one.
  • That all hosts running Wasm follow WASI.
  • That using a Long-Term Support (LTS) version will guarantee API stability.

1.2 Scope and Exclusions

This article covers the following topics: versions and naming conventions for WASI, the Component Model and WIT (within the scope of design considerations), permissions granted by the host, the four places a host runs with their hosts and operators, a comparison of isolation boundaries, runtime support policies, toolchain readiness, decisions about where to place a host on AWS, and failure modes.

This article does not cover:

  • A timeline of Wasm and WASI. Only version dates relevant to design decisions will be mentioned.
  • Wasm within browsers.
  • Pricing, performance comparisons, benchmarks, or product evaluations.
  • Build procedures for different languages. Command details will be kept to a minimum.
  • Procedures for creating Kubernetes clusters.
  • Methods for escaping the sandbox. This article will only describe where the boundaries lie.
  • Isolation levels within Amazon EKS and the RuntimeClass mechanism. This is covered in Chapter 5 of this site's Workload Isolation Levels on Amazon EKS.
  • Selecting isolation units on AWS. This is covered in this site's Agent Sandboxing and Blast-Radius Isolation on AWS.
  • Mechanisms for running AI agent-generated code within a V8 isolate or Wasm environment. This is covered in Chapter 5 of this site's Where the Orchestration Program Runs.

This site's Which Lines of the AWS Helm Instructions Change Under Helm 4 lists writing plugins for Wasm as one of the topics not covered. This article covers what Helm 4's Wasm runtime grants in Section 3.5.

1.3 Date of Review and Materials Reviewed

This article is based on a review conducted on November 20, 2026 (Japan Standard Time), using the following materials. In the body, this article uses the English names in parentheses.

Regarding wasi.dev, the following pages were reviewed:

  • Introduction (introduction page)
  • Releases (releases page)
  • Roadmap (roadmap page)
  • Security (security page)
  • Languages (languages page)

Regarding the Bytecode Alliance and W3C materials, the following pages were reviewed:

  • List of WASI GitHub releases (WASI GitHub releases)
  • Pages related to The WebAssembly Component Model, including Why the Component Model?, Components, Worlds, and WIT Reference (Component Model docs)
  • News section on webassembly.org (webassembly.org news)
  • W3C WebAssembly Core Specification (W3C Core page)

Regarding Wasmtime, the following materials were reviewed:

  • The Release Process page and its corresponding docs/stability-release.md (Wasmtime release page)
  • The Security page (Wasmtime security page)
  • The CLI Options page (Wasmtime CLI page)
  • The Interrupting Execution page (Wasmtime interruption page)
  • List of GitHub releases, security advisories, and individual advisory pages (Wasmtime advisories)

Regarding host and location materials, the following pages were reviewed.

  • Docker Docs on Wasm workloads (Docker Desktop Wasm page)
  • The WebAssembly (Wasm), How Workers works, and Rust pages of Cloudflare Workers (Workers pages)
  • Fastly Compute introductory page (Fastly Compute page)
  • CNCF project pages for Spin, SpinKube, and wasmCloud (CNCF project pages), and the Spin manifest reference page (Spin manifest page)
  • containerd/runwasi README and release list (runwasi)
  • Envoy's Wasm page (Envoy Wasm page) and the Istio WasmPlugin reference page (Istio WasmPlugin page)
  • Helm plugins overview page (Helm plugins page) and the Extism site (Extism site)
  • Kubernetes Runtime Class page (Kubernetes RuntimeClass page)
  • What is gVisor? page (gVisor page) and the Firecracker site (Firecracker site)

Regarding language toolchains, this article read the Rust blog post from April 9, 2024 (Rust WASI targets post), the rustc Platform Support pages (rustc platform pages), and the Go 1.24 release notes (Go 1.24 release notes).

On AWS, this article reviewed the following materials.

  • AWS Containers Blog – How to Run WebAssembly on Amazon EKS (EKS Wasm blog post)
  • GitHub – aws/containers-roadmap, issue 1997 (roadmap issue)
  • AWS Lambda Developer Guide – Lambda runtimes (Lambda runtimes page)
  • Amazon CloudFront Developer Guide – Restrictions on Lambda@Edge (Lambda@Edge restrictions page), and AWS Networking & Content Delivery Blog – Charting the life of an Amazon CloudFront request (CloudFront request blog post)

This article read pages outside of AWS, as well as the Lambda runtimes page, as raw text obtained with curl. For the other AWS documentation, this article used AWS Knowledge's search and reading features. The AWS documentation was searched three times, using different search terms.

1.4 Terms, and Different Things with the Same Spelling

This article uses the following terms consistently:

  • Module: A single binary in the core WebAssembly format, capable of using WASI 0.1.
  • Component: A binary built according to the Component Model. It may contain one or more modules or components, and is capable of using WASI 0.2 and 0.3.
  • World: A contract written in WIT. The Component Model docs describe this as a description of the functionality a component provides and the functionality required for it to run.
  • Host: A program that loads Wasm code and executes it by fulfilling import requirements. This can include applications, proxies, edge servers, and containerd shims.
  • Wasm runtime: An engine embedded by the host that executes Wasm. Examples include Wasmtime, WasmEdge, Wasmer, and WAMR.
  • Grant (capability): An entry point to external resources that the host allows the Wasm code to use. This can include files, networks, environment variables, clocks, and random numbers.
  • Isolation boundary: A boundary that prevents the code within it from accessing external resources or interacting with other code.
  • Operator of the host: The entity responsible for running the host process, upgrading the runtime version, and applying updates. This article distinguishes between the author of the host and the operator. For example, the Helm project writes the Helm 4 host, while the operator is the user who runs Helm.

The sources this article read use the same spelling for different things.

  • WASI versions are also known by the following names: 0.1 is referred to as Preview 1, P1, wasip1, or wasi_snapshot_preview1. 0.2 is known as Preview 2, P2, or wasip2, and 0.3 is referred to as Preview 3, P3, or wasip3. The older Rust target wasm32-wasi was an earlier name for version 0.1. Unless otherwise specified, this article refers to versions 0.1, 0.2, and 0.3.
  • Component: In this article, "component" refers only to components in the Component Model. It is not used to mean parts or elements in the context of Kubernetes or AWS.
  • Runtime: Wasm runtimes, the runtime shims for containerd, Lambda runtimes, and Kubernetes RuntimeClasses are all distinct layers. Unless otherwise stated, this article refers to Wasm runtimes when using the term "runtime."
  • Isolate: In this article, "isolate" refers specifically to V8 isolates. It is not used in the general sense of "isolation."
  • Wasm and WASI Versions: The versions of Wasm Core (2.0, 3.0) and the versions of WASI (0.1, 0.2, 0.3) are separate specifications.
  • LTS: In the context of Wasmtime, "LTS" refers to versions that receive a longer period of support. It does not mean that the API remains unchanged (see Section 6.1).
  • Spin: In this article, "Spin" refers to the name of the project in the CNCF Sandbox.

1.5 Terms for the State of the Sources

This article uses the following six terms to describe the state of the documentation. These terms, including their English spellings, are also used in the tables.

  • Stated: The documentation contains a statement regarding the matter.
  • Stated as not supported: The documentation explicitly states that the matter is not supported or cannot be used.
  • Documentation does not list: While a list or table exists, the specific item is not included. This does not necessarily indicate that the matter is unsupported or unavailable.
  • No statement found: Despite searching using different keywords and categories of documentation (as described in Section 1.3), no relevant statement could be found. This does not necessarily indicate that the matter is absent or impossible.
  • Sources disagree: The statements regarding the same matter in two different documents are contradictory. This article presents both statements, along with their sources, without designating either as incorrect.
  • Inference: This is an inference made by this article, and is not a statement found in any of the documentation. This article says in the same sentence that it is an inference.

All dates referenced in this article are presented with the year. Pages may be rewritten after the verification date.

2. Target Versions

This chapter outlines the three versions of WASI, their current status, and where the sources disagree.

2.1 Three Versions of WASI

The introduction page describes the versions of WASI as follows:

To date, WASI has seen three milestone releases: 0.1, 0.2, and 0.3. (Sometimes you will see these referred to as Preview 1/2/3 or P1/P2/P3.)

The same page states that version 0.3 added asynchronous capabilities to the Component Model and redesigned the WASI interface to use types such as stream<T> and future<T>.

Table 1 lists the three versions. The "Status" column uses terminology from the releases page, and the verification date is November 20, 2026.

VersionOther NamesUnit UsedHow Access Is GrantedStatusRelease Date
0.1Preview 1, P1, wasip1moduleFile descriptors opened at startupLegacyNot covered in this article
0.2Preview 2, P2, wasip2componentWIT importsStable, superseded by 0.3End of January 2024 (releases page)
0.3Preview 3, P3, wasip3componentWIT imports and the world boundaryStable, currentJune 11, 2026 (roadmap page)

The term Legacy does not mean that it is not being used. The releases page states the following regarding version 0.1:

Since WASI 0.2 was released end of January 2024, WASI 0.1 support is more widespread among Wasm runtimes, and it is widely used in production today.

Regarding version 0.2's designation as superseded, this does not mean that support has ended. The language on the releases page indicates that version 0.3 is the current version.

2.2 0.3 Patch Releases, and 0.3.2, Where the Sources Disagree

The roadmap page describes the schedule for 0.3 patch releases as follows:

WASI 0.3 patch releases ship every two months, on the second Tuesday.

Version 0.3.0 was released outside of the established schedule. The roadmap page states:

WASI 0.3.0 was an exception to the release train, shipping on June 11, 2026 following a WASI Subgroup vote. WASI 1.0 may also be scheduled outside the train. The cadence after 1.0 is undetermined.

The release date for version 1.0 is not documented. This article does not specify when version 1.0 will be released.

Regarding version 0.3.2, two sources disagree. Table 2 presents both statements. The verification date is November 20, 2026.

ItemRoadmap PageWASI GitHub ReleasesStatus
0.3.1August 11, 2026, Shippedv0.3.1, August 11, 2026Stated
0.3.2October 13, 2026, Plannedv0.3.2, October 13, 2026Sources disagree
0.3.3December 8, 2026, PlannedNot listedStated (Planned)

The GitHub listing indicates that v0.3.2 has already been released. However, the roadmap page continues to list it as planned. This article does not decide that either source is incorrect. When pinning a version, check both sources.

The roadmap page describes Wasmtime support as follows:

WASI 0.3 support is available in Wasmtime 46 and later, which enables WASI 0.3 by default, and in jco.

2.3 Status of Core Specifications

The webassembly.org news announced Wasm 2.0 as Completed on March 20, 2025, and Wasm 3.0 as Completed on September 17, 2025.

The URL for the W3C Core page includes wasm-core-2. However, this page's version is a Candidate Recommendation Draft dated November 16, 2026, and states that it outlines the content of Wasm 3.0. The same page also states:

The WebAssembly Working group intends to maintain this publication in the Candidate Recommendation state and continually update it as a "living standard" rather than transition to Recommendation state.

This article does not refer to Wasm 2.0 and 3.0 as W3C Recommendations. This article treats the Completed reported on webassembly.org news as an announcement separate from the status of W3C documents.

2.4 Version Selection

The choice of version is determined by both the host and the toolchain. Even if the host accepts version 0.3, if the toolchain used for building does not support 0.3, you should aim for version 0.2. The languages page states the following:

Other toolchains have not yet shipped 0.3 support, so target WASI 0.2 with those.

Details on language support can be found in Section 7.1, while host-specific compatibility is outlined in Chapter 4.

3. What the Host Grants

This chapter details what the host grants to the Wasm code and how, covering different versions of WASI, as well as hosts that do not follow WASI.

What the Host Grants Across WASI Versions
What the Host Grants Across WASI Versions

3.1 Nothing Is Granted by Default

The security page describes the philosophy behind WASI as follows:

Code running under WASI has no ambient authority: a WebAssembly module or component starts with no access to the outside world and can only perform operations that the host explicitly grants.

The same page refers to WASI as deny-by-default and explains how WASI differs from processes on Linux or Windows. Processes on these operating systems inherit the broad permissions of their user, granting access to files, networks, and environment variables. WASI code only has access to what the host grants.

This description reflects the way WASI's own documentation explains its functionality. The security page further states that WASI's sandbox offers stronger isolation than that provided by typical operating system processes. This article simply cites this comparison as a claim made within WASI's documentation. The extent of this protection will be discussed in Chapter 5, in conjunction with the host implementation.

3.2 0.1: File Descriptors Opened at Startup

A 0.1 module imports functions from wasi_snapshot_preview1. The security page specifies that the module can only access resources provided by the runtime at startup, primarily preopened file descriptors. The module cannot request new file descriptors.

Permissions are granted when the module is executed. The security page clarifies that these permissions are not defined in the module's binary itself, but rather are provided at the time of execution. For example, in the Wasmtime CLI, the --dir flag specifies the directory to grant.

wasmtime --dir . foo.wasm

The Wasmtime CLI page states that Wasmtime flags should be placed before the .wasm file. Flags placed after the file are treated as arguments to the Wasm program.

wasmtime foo.wasm --dir .

With the second form, Wasmtime grants no directory. --dir . becomes arguments to foo.wasm.

3.3 0.2: WIT Imports

In 0.2, the permissions are reflected in the component's type. The security page states:

WASI 0.2 components express capabilities directly in WIT.

The same page indicates that files, networks, environment variables, clocks, and random numbers each correspond to a separate import. The host will execute the component by fulfilling only the imports it has chosen to grant. Examining the component's binary will reveal what imports it requires.

This article considers this property useful for checking before granting permissions. This is because the list of imports corresponds to the list of required permissions. This is an inference.

A set of imports is fixed as a world. The Component Model docs provide the wasi:cli world in WASI as an example. This world imports functions commonly used by command-line programs, such as file input/output, random numbers, and clocks, and provides a single export to execute the command. The same docs state that the host corresponding to this world must provide implementations for all of the imports.

This article interprets the requirement to provide implementations for the imports as distinct from actually providing specific resources, such as directories. For example, in the Wasmtime CLI described in Section 3.2, the directory to be provided is specified using the --dir flag. This is an inference.

3.4 0.3: The World Boundary

Even in version 0.3, the mechanism by which the host grants access remains unchanged. What has changed is how the guest code manages permissions. The security page describes this as follows:

The host still grants network access at the world boundary; guests no longer plumb the handle through every operation.

In version 0.2, the guest would pass handles for wasi:sockets/network every time it performed bind, connect, or DNS queries. In version 0.3, the guest no longer passes those handles through every operation. Whether or not to grant network access continues to be determined by the host at the world boundary.

This article does not read version 0.3 as an expansion of the permissions granted by the host. Even in the 0.3 column of Figure 1, the host remains the entity responsible for granting access.

3.5 What Hosts That Do Not Follow WASI Grant

Not every Wasm host follows WASI. The following hosts provide functions to Wasm code under rules other than WASI.

  • Helm 4: The Helm plugins page states that the plugin runtime has two options: subprocess and extism/v1. Plugins that choose extism/v1 require a plugin.wasm file. The configuration includes options such as allowedHosts, fileSystem, and hostFunctions. The Helm plugins page also states that if allowedHosts is not specified, no hosts are allowed.
  • Envoy and Istio: The Envoy Wasm page indicates that Envoy executes Wasm modules written according to the Proxy-Wasm specification, recommending the 0.2.1 ABI for Proxy-Wasm. The Istio WasmPlugin page describes an extensions.istio.io/v1alpha1 WasmPlugin, stating that it allows adding Wasm filters to Istio proxies. Proxy-Wasm has a different ABI than both WASI and the Component Model.
  • Cloudflare Workers: The Workers pages state that Workers largely support the same Wasm features as Google Chrome, and regarding WASI, they state:

WASI support is experimental on Cloudflare Workers, with only some syscalls implemented.

In Spin, permissions are defined in the application's manifest. The Spin manifest page describes allowed_outbound_hosts as a list of addresses to which Wasm components are permitted to send network requests. The example value on the same page is an empty list.

The Extism site states that Extism completely sandboxes the execution of plugin code. This article will simply cite this statement as Extism's own claim.

3.6 Who Decides What to Grant

In the examples discussed so far, the entity that determines access permissions varies depending on the location.

  • When running a module using the Wasmtime CLI, the user executing the command determines access via the --dir flag.
  • In Helm 4 plugins, access is controlled by specifying allowedHosts and similar settings in the plugin configuration. The user executing Helm decides which plugins to install.
  • For Spin applications, access is defined in the application's manifest.

This article treats access permissions not based on the characteristics of the Wasm code itself, but rather as a configuration setting on the host environment. Even with the same .wasm file, the capabilities can differ depending on the host's configuration. This is an inference.

4. Where the Host Runs

This chapter outlines four places to run the Wasm host and shows, for each, the host, the operator, and WASI support.

Where a Wasm Host Runs and Who Operates It
Where a Wasm Host Runs and Who Operates It
Table 3 lists these four locations, along with examples. The "WASI" column gives the statements in the pages listed in Section 1.3. The verification date is November 20, 2026.

LocationExampleRuntime within HostOperator of the HostWASI
In-process pluginHelm 4's extism/v1ExtismUsers running HelmNo statement found (Helm plugins page)
In-process pluginEnvoy and Istio's Wasm filtersEnvoy's Wasm runtimeUsers operating proxies and meshesNot used (Proxy-Wasm ABI)
Edge serverFastly ComputeWasmtime (Stated)FastlyNo statement found (Fastly Compute page)
Inside a JavaScript hostCloudflare WorkersV8CloudflareExperimental (Stated)
Kubernetescontainerd and runwasi shimWasmtime, WasmEdge, Wasmer, WAMRUsers operating the clusterStated (runwasi)

4.1 In-Process Plugins

For an in-process plugin, the application acts as the host. In Helm 4, Helm itself, developed by the Helm project, runs the extism/v1 plugins. Users who execute Helm are responsible for running it and upgrading its version.

Similarly, Envoy and Istio's WebAssembly filters also have the proxy acting as the host. The Envoy project provides the host implementation, and users who operate the proxy are responsible for upgrading it.

As shown in Chapter 5, it is the host's code that enforces the boundaries. For in-process plugins, that host code is distributed along with the application itself.

4.2 Edge Servers

On an edge server, the vendor operates the host. The Fastly Compute page states:

Security and portability are provided by compiling your code to WebAssembly. We run your code using Wasmtime.

This article suggests that in Fastly Compute, the vendor is responsible for upgrading the runtime and applying updates, while users determine which language SDK to use and which features to use. This is an inference.

According to CNCF project pages, Spin was accepted into the CNCF Sandbox stage on January 21, 2025. Open-source hosts like Spin have their operators change depending on who runs them. This is an inference.

4.3 Inside a JavaScript Host

In Cloudflare Workers, WebAssembly (Wasm) runs within a JavaScript host environment. The Workers pages state that the Workers runtime uses the V8 engine and runs code in isolates. The same pages state that an isolate can be considered a sandbox.

Workers is not built as a WASI host for Wasm. The Rust page of the Workers pages uses wasm32-unknown-unknown as the build target. WASI is currently experimental and only implements a limited set of system calls, as described in Section 3.5. The Workers pages also state that threads cannot be used.

An example of running code generated by an AI agent within a V8 isolate is covered in Chapter 5 of this site's Where the Orchestration Program Runs. The same chapter also discusses an example where Pi's Codemode runs QuickJS within a Wasm execution environment.

4.4 Kubernetes

In Kubernetes, a containerd shim acts as the host. runwasi identifies itself as:

Facilitates running Wasm / WASI workloads managed by containerd

The list of runwasi releases includes shim implementations for Wasmtime, WasmEdge, Wasmer, and WAMR. On June 12, 2026, version 0.6.1 of the Wasmtime, Wasmer, and WasmEdge shims, version 0.2.1 of the WAMR shim, and version 1.0.1 of containerd-shim-wasm were released.

Kubernetes allows you to select which shim a Pod uses through the RuntimeClass. The Kubernetes RuntimeClass page describes this feature as a way to select the container runtime configuration. Chapter 5 of this site's Workload Isolation Levels on Amazon EKS discusses the mechanisms behind RuntimeClass and how to select isolation levels within Amazon EKS.

In Kubernetes, whoever puts the shim into the node image and upgrades it operates the host. In the setup of the EKS Wasm blog post, that is the user (Section 6.5). According to the CNCF project pages, SpinKube was accepted at the Sandbox stage on January 21, 2025, and wasmCloud moved to the Incubating stage on November 8, 2024.

5. Where Isolation Boundaries End

This chapter describes what Wasm host isolation boundaries protect and what they do not, and compares them to other boundaries.

5.1 What the Boundary Protects

The Wasmtime security page describes Wasm as follows:

WebAssembly is inherently sandboxed by design (must import all functionality, etc).

The same page lists the properties inherent in the core specification of Wasm. For example, the call stack is inaccessible from Wasm code. The return address is stored in memory that only the implementation can access. Memory is isolated between instances.

To access external resources, Wasm code must go through imports. As described in Chapter 3, it is the host that fulfills these imports. The boundary protects resources that have not been granted, as well as the memory of other instances.

5.2 What the Boundary Does Not Protect

The Wasm boundary does not protect the following three things.

The first is the usage of granted permissions. If the host provides access to directories or networks, the Wasm code can read, write, and connect within that scope. Boundaries are not a mechanism to prevent the use of what has been provided.

The second is defects in the host's implementation. The Wasmtime security page states:

While WebAssembly is designed to be sandboxed bugs or issues inevitably arise so Wasmtime also implements a number of mitigations which are not required for correct execution of WebAssembly but can help mitigate issues if bugs are found:

The Wasmtime advisories list several advisories, including one published on October 29, 2026 (GHSA-hmmr-87qq-258j), which describes a defect where, for UDP sends in version 0.3, the host's configured limits on destinations were not always enforced. The advisory identifies this as a defect in the host's implementation of wasi:sockets/types.udp-socket. The affected hosts used unpatched versions of wasmtime-wasi from 48.0.0 onward, exposed 0.3 sockets to the guest, and had configured policies on a per-address basis. The advisory notes that the Wasmtime CLI and 0.2 sockets are not affected.

This example shows that the check of granted permissions is also implemented by the host's code. Defects in permission boundaries can only be resolved through updates to the runtime.

The third is resource exhaustion. Another advisory, published on the same day (GHSA-6fr9-xmw9-5352), describes a defect where, when borrowed resources are transferred between components, the host's memory could grow without limit. The advisory calls this a denial-of-service.

The host also controls execution time. The Wasmtime interruption page states:

If you want to interrupt Wasm execution, for example to prevent an infinite loop in the Wasm guest from indefinitely blocking the host, Wasmtime provides two mechanisms you can choose between.

The two mechanisms are fuel and epochs. The same page notes that fuel-based interruption is deterministic and imposes more overhead on execution than epochs do. The choice of which mechanism to use and where to set the limits is determined by the host's configuration.

This article does not claim that placing code in Wasm guarantees its security. The scope of protection is determined by what the host grants and the correctness of the host's implementation.

5.3 Comparing with Other Boundaries

Table 4 compares the boundaries of the Wasm host with other boundaries. Each row gives what the sources for that boundary state. Performance comparisons are not included.

BoundaryBoundary Creation MechanismWhat the Boundary Separates (as described in the documentation)DocumentationDetailed Articles
Wasm hostThe runtime, and the imports that the host fulfillsMemory between instances. External resources are only accessible through the imports that the host grants.Wasmtime security page, security pageThis article
V8 isolateV8 engineMemory between isolatesWorkers pagesWhere the Orchestration Program Runs
gVisorAn application kernel with a Linux-like interface that runs in user spaceApplications and the host operating systemgVisor pageWorkload Isolation Levels on Amazon EKS
Firecracker microVMIsolation provided by KVMContainers and functions for multiple usersFirecracker siteHow AWS Lambda Execution Environments Work

The units of these boundaries vary from row to row. The Wasm host and V8 isolate both separate units of code within a single runtime. The Workers pages state that a single runtime instance can run hundreds to thousands of isolates. gVisor sits between an application and the host operating system. MicroVMs provide isolation at the level of virtual machines. The term "isolation" is used in different contexts, referring to different units.

The selection of these units is discussed in detail on this site in Agent Sandboxing and Blast-Radius Isolation on AWS.

5.4 Layering Boundaries

The boundaries of a Wasm host, as well as those of processes and virtual machines, are not mutually exclusive choices. The runwasi shims run on a Kubernetes node. While the Fastly Compute page mentions running user code with Wasmtime, the surrounding infrastructure details are not described in the pages referenced in this article.

This article regards a design that places an additional boundary outside the Wasm boundary when running third-party code as a way to prepare for defects in the host. This is an inference.

6. Who Keeps the Host Patched

This chapter explains how runtime and WASI versions move, and who applies the fixes.

6.1 Wasmtime Versions and LTS

The Wasmtime release page describes the versioning process as follows:

A new major version of Wasmtime will be made available on the 20th of each month.

Each release that is a multiple of 12 is considered an LTS release and is supported for 24 months.

The same page states that other versions are supported for two months, and addresses security vulnerability fixes as follows:

Security bugs are guaranteed to be backported to all supported releases.

Multiple versions can be supported simultaneously. The Wasmtime release page indicates that two LTS (Long-Term Support) versions and up to two other versions are supported. As of November 20, 2026, the GitHub release list includes v50.0.3, v49.0.7, v48.0.10, v36.0.23, and v51.0.0-rc.1.

LTS does not guarantee that the API will remain unchanged. The Wasmtime release page states:

Each major release of Wasmtime reserves the right to break both behavior and API backwards-compatibility.

The Wasmtime release page includes a table listing the end-of-support dates for each version. However, the page accessed for this article did not display the contents of this table. This article does not list end-of-support dates.

6.2 The Releases One Fix Reached

The advisory GHSA-6fr9-xmw9-5352 from Section 5.2 lists the patched versions as 36.0.20, 48.0.8, 49.0.5, and 50.0.1. These four versions belong to the four series in the list in Section 6.1 (the LTS versions 36 and 48, and the normal versions 49 and 50). Fixes for all four series were released on the same day.

A released fix does not reach a host by itself. It is the operator of the host who applies the update. The following split is this article's inference from the operators in Chapter 4 (Inference).

  • On edge servers, the vendor applies the update.
  • In Kubernetes, the operator managing the cluster upgrades the node shim and the runtime version within it.
  • For in-process plugins, the developer of the application upgrades the embedded runtime version and releases an updated version, which users then update.

Versions that have reached the end of their support period will not receive updates. Applications that incorporate Wasmtime should plan to transition to the next LTS version within 24 months, even if they choose an LTS version. This is an inference.

6.3 The WASI Release Train

WASI versions move as well. As mentioned in Section 2.2, 0.3 patch releases ship every two months. The languages page explains how to align the tool versions as follows:

Until they do, target the same version (0.3.0) across all WIT-aware tools. Mismatches surface as confusing wrong type errors at instantiation.

When upgrading the WASI version, it is important to update both the host and the toolchain together.

6.4 Docker Desktop's Wasm, containerd, and runwasi

The Docker Desktop Wasm page indicates the feature's status as Beta and states the following:

Wasm workloads are deprecated and will be removed in a future Docker Desktop release. This feature is no longer actively maintained.

No statement was found on the release or date of the removal (No statement found).

Docker Desktop's Wasm is separate from containerd and runwasi within Kubernetes. No statement of discontinuation was found in runwasi's README or release list (No statement found). This article does not read the deprecation in Docker Desktop as a deprecation of runwasi.

6.5 Where to Place a Host on AWS

On AWS, no description of a managed runtime for running Wasm was found (No statement found). This article does not state that AWS cannot run Wasm. What was not found was a description of a Wasm host that AWS operates.

The available AWS documentation includes the following:

  • EKS Wasm blog post (August 20, 2024): A sample demonstrating the creation of custom AMIs for Amazon EKS using HashiCorp Packer, and running Spin and WasmEdge using a RuntimeClass.
  • Roadmap issue: A proposal to support Wasm containers using WASI on Amazon EKS. As of November 20, 2026, it is Open, at the Proposed stage.
  • Lambda runtimes page: No mention of Wasm is present. The same page recommends using OS-only runtimes for languages that compile to native binaries, such as Go and Rust.
  • Lambda@Edge restrictions page: This page states that Lambda@Edge supports Node.js and Python runtimes. The CloudFront request blog post describes CloudFront Functions as lightweight JavaScript functions.

In the setup of the EKS Wasm blog post, the user builds and upgrades the node image, the shim, and the runtime version. The operator of the host is the user.

The Lambda runtimes page does not describe a configuration that involves running a Wasm runtime within an OS-only runtime. This article presents this configuration as a potential design option, the feasibility of which has not been verified. This is an inference.

7. Toolchain Readiness and Failure Modes

This chapter outlines the available WASI versions for each programming language, as well as failure modes.

7.1 Language Support

Table 5 extracts the relevant rows from the languages page, which are necessary for the judgments made in this article. The verification date is November 20, 2026.

LanguageToolchainOutputWASI Version
Rustwasm32-wasip2 and wasm32-wasip3 targetsModules and Components0.1, 0.2. 0.3 through a crate.
GoUpstream Go (GOOS=wasip1)Modules0.1
Gogo-modules and TinyGoComponents0.2
JavaScript and TypeScriptjcoComponents0.2. 0.3 is experimental.
Pythoncomponentize-pyComponents0.2
C and C++wasi-sdkModules. Components are created through conversion.0.1, 0.2
C#componentize-dotnetComponents0.2. The toolchain is in a pre-release status.

Regarding Rust, the languages page states:

wasm32-wasip2 is Tier 2 on stable; wasm32-wasip3 is Tier 3, nightly only.

The same page also notes that the standard library for wasm32-wasip2 still uses version 0.2.

For Go, the upstream Go produces modules at version 0.1. The Go 1.24 release notes indicate that it is now possible to build Go programs as libraries using WASI Preview 1 (GOOS=wasip1 GOARCH=wasm).

7.2 Failure Modes

The following failures can arise from the statements in the sources covered so far.

  • Confusing version names for WASI. 0.1, Preview 1, wasip1, and wasi_snapshot_preview1 all refer to the same version. The Rust WASI targets post stated that the older Rust target wasm32-wasi would be removed in Rust 1.84. The list in the rustc platform pages as of November 20, 2026, does not include wasm32-wasi (Documentation does not list) (see Section 1.4).
  • Interpreting outdated information as current. The wasm32-wasip2 page on the rustc platform pages lists it as Tier 2, while it still carries a sentence saying the target was experimental as of January 2024.
  • Using mismatched WASI versions between the toolchain and the host. The languages page indicates that using incompatible versions can lead to obscure type errors during instantiation (see Section 6.3).
  • Attempting to target version 0.3 when the toolchain has not caught up. The languages page lists support for 0.3 as limited to the Rust wasip3 crate and experimental features in jco (see Section 7.1).
  • Granting overly broad permissions. Passing a wide range of directories to --dir allows the Wasm code to access the entire directory (see Sections 3.2 and 5.2).
  • Placing Wasmtime flags after the .wasm file, resulting in permissions not being passed as intended (see Section 3.2).
  • Assuming safety due to running within Wasm, and therefore not tracking updates to the runtime. Defects in the boundary are in the host implementation (see Section 5.2).
  • Misinterpreting Wasmtime's LTS as a version with a stable API (see Section 6.1).
  • Reading Proxy-Wasm filters and Cloudflare Workers' Wasm as WASI hosts (see Sections 3.5 and 4.3).
  • Interpreting the deprecation of Wasm in Docker Desktop as the deprecation of containerd and runwasi (see Section 6.4).
  • Reading the URL for W3C's wasm-core-2 as referring to a 2.0 specification that is a W3C Recommendation (see Section 2.3).
  • Reading the absence of a statement about a managed runtime on AWS as meaning that Wasm cannot run on AWS (see Section 6.5).

8. A Decision Table

This chapter presents a series of questions, summarizing the material covered thus far, to help guide your decision-making process when determining the appropriate location.

8.1 Location-Specific Decisions

Table 6 outlines, for each location, the operator of the host, where grants are set, and what to check.

LocationOperator of the HostWhere Grants Are SetWhat to Check
In-process pluginApp developer and the user executing the appHost configuration (e.g., allowedHosts in Helm 4)Version and advisories for the embedded runtime, and the imports passed to the plugin.
Edge serverVendorThe vendor's API and user settingsWASI description on the vendor's page, SDK compatibility.
Inside a JavaScript hostVendorJavaScript host's APIWhether WASI is experimental, and the build target.
KubernetesUser managing the clusterRuntimeClass and shim configuration, app manifestVersion of the node image shim, and runtime advisories.
On AWSUser (as configured in the EKS Wasm blog post)Same as the Kubernetes row aboveProcedure for recreating custom AMIs, and the status of roadmap issues.

8.2 Where the Sources Disagree, and Where No Statement Was Found

This article treats the following as Sources disagree:

  • WASI 0.3.2 status: The roadmap page indicates Planned, while the WASI GitHub releases show a release date of October 13, 2026 (Section 2.2).

This article treats the following as No statement found:

  • A managed Wasm runtime operated by AWS (Section 6.5).
  • The Docker Desktop release, and its date, that removes Wasm (Section 6.4).
  • The discontinuation of runwasi (Section 6.4).
  • Statements about WASI on the Helm plugins page and the Fastly Compute page (Table 3).
  • The dates when support for each version of Wasmtime ends. A table exists, but it was not displayed on the page referenced in this article (Section 6.1).

In addition, one source contains a date listed in two different ways. The Rust WASI targets post lists the date when Rust 1.84 removes wasm32-wasi as both January 5, 2025 and January 9, 2025. This article simply lists "Rust 1.84" without specifying a date.

9. Frequently Asked Questions About WebAssembly Outside the Browser

Q1. Can third-party code be run securely when placed within WebAssembly?

Putting code in Wasm does not guarantee that third-party code can be run safely. While Wasm code can reach only the imports the host grants, within the scope of those granted permissions, it can read, write, and connect. Implementing boundaries is the responsibility of the host code, and vulnerabilities can sometimes be found on the host side, as demonstrated by a Wasmtime advisory from October 29, 2026 (see Section 5.2).

Q2. Which version of WASI – 0.1, 0.2, or 0.3 – should you target?

Target a version that the host accepts and the toolchain can emit. As of November 20, 2026, the languages page lists support for version 0.3 only for the Rust wasip3 crate and for the experimental features of jco. The languages page recommends targeting version 0.2 for other toolchains (see Sections 2.4 and 7.1).

Q3. Are Preview 2 and 0.2 different versions?

They are the same version. The introduction page states that 0.1, 0.2, and 0.3 are also referred to as Preview 1/2/3 or P1/P2/P3 (Section 2.1).

Q4. In version 0.3, did the permissions granted by the host expand?

No, they did not. The security page states that in version 0.3, the host still grants network access at the world boundary. The change is that the guest is no longer required to pass the handle with each call (see Section 3.4).

Q5. Are Cloudflare Workers and Envoy's Wasm also WASI hosts?

They were not created as WASI hosts. The Workers pages describe WASI support as experimental. Envoy and Istio run filters using the Proxy-Wasm ABI (see Sections 3.5 and 4.3).

Q6. Does using the LTS version of Wasmtime mean the API will remain unchanged?

It may change. The Wasmtime release page states that each major release could potentially break compatibility with previous behavior and APIs. LTS versions are those with a 24-month support period (see Section 6.1).

Q7. If Docker Desktop's support for WebAssembly is being deprecated, does that mean Kubernetes's support for WebAssembly will end as well?

They are separate. The deprecation notice for Docker Desktop Wasm refers to features within Docker Desktop. No statement of deprecation was found for runwasi (see Section 6.4).

Q8. Where should you deploy Wasm on AWS?

No statement was found about a managed Wasm runtime operated by AWS. AWS documentation provides a sample demonstrating how to create custom AMIs within Amazon EKS and run Spin and WasmEdge using a RuntimeClass. In this configuration, the user is responsible for managing the host environment (as described in Section 6.5).

10. Summary

Design Wasm outside the browser around three decisions.

  • What the host grants: WASI code reaches only what the host grants. This includes 0.1 (file descriptors opened at startup), 0.2 (WIT imports), and 0.3 (grants at the world boundary). Helm 4's extism/v1, Proxy-Wasm, and Cloudflare Workers grant access under rules other than WASI.
  • Where the isolation boundary ends: The boundary protects resources that have not been granted and the memory of other instances. It does not protect against misuse of granted permissions, flaws in the host's implementation, or resource exhaustion. The host's code is responsible for implementing this boundary.
  • Who manages and fixes the host: On edge servers, the vendor applies runtime fixes. For Kubernetes and in-process plugins, the user side applies them (Inference; Section 6.2). Wasmtime releases a major version every month and supports each release whose number is a multiple of 12 for 24 months. Wasm in Docker Desktop is deprecated.
  • Versions: WASI 0.3 was released on June 11, 2026. For version 0.3.2, the sources disagree. There are currently few toolchains available that support WASI 0.3.
  • AWS: No descriptions for managed Wasm runtimes have been found. In the EKS sample, the user manages the host.

11. References



References:
Tech Blog with curated related content

Written by Hidekazu Konishi