WebAssembly in Production: Edge Functions & Runtime Performance 2026

WebAssembly has graduated from browser curiosity to production edge compute. Running Rust-compiled WASM in Cloudflare Workers processes SHA-256 hashes 5x faster than JavaScript. Fastly Compute uses WASM as its primary runtime, achieving sub-1ms cold starts. This guide covers everything you need to deploy WASM at the edge in 2026.

What Is WebAssembly?

WebAssembly (WASM) is a binary instruction format — a compact, portable bytecode that runs in a sandboxed virtual machine. Think of it as a new kind of assembly language that any language can compile to, and any environment can run.

Key properties that make WASM valuable for edge compute:

• Near-native performance: WASM runs at 60-90% of native speed for CPU-intensive tasks
• Deterministic execution: Same behavior across all platforms (browser, server, edge)
• Sandboxed: No access to host system without explicit permission (WASI)
• Compact: Rust WASM binaries are typically 100KB-2MB (vs 50MB+ Docker images)
• Fast startup: V8 isolates compile WASM to native code ahead of first execution

Languages that compile to WASM: Rust, C/C++, Go, AssemblyScript, C#, Kotlin, Swift, Python (Pyodide), JavaScript (via WASM JIT).

---

WASM Edge Runtime Environments

Cloudflare Workers + WASM

Cloudflare Workers has supported WASM since 2018. Workers compile WASM to native code at deploy time (using V8’s AOT compiler), achieving zero runtime compilation overhead.

Limits:

• WASM modules: up to 2MB per module
• Total Worker size: 1MB compressed (Free), 10MB (Paid)
• CPU time: 10ms (Free), 50ms (Paid) — includes WASM execution

# wrangler.toml — enable WASM modules
name = "edge-crypto"
main = "src/worker.ts"
compatibility_date = "2026-01-01"

# WASM modules are automatically detected from imports
# [[rules]]
# type = "CompiledWasm"
# globs = ["**/*.wasm"]

Fastly Compute + WASM

Fastly Compute (formerly Compute@Edge) is unique: WASM is the primary runtime, not an add-on. Every Fastly function is compiled to WASM. This gives Fastly the fastest cold starts of any edge platform (under 1ms via WASM isolation).

Supported compile targets: Rust (first-class), Go (tinygo), JavaScript (js-compute), AssemblyScript, C.

Node.js and Deno

Both Node.js (v8+) and Deno support WASM via the standard WebAssembly API. No special flags required.

// Load WASM in Node.js (no Edge restrictions)
import { readFile } from 'node:fs/promises';
const wasmBuffer = await readFile('./crypto.wasm');
const { instance } = await WebAssembly.instantiate(wasmBuffer);
const result = instance.exports.hash_sha256(inputBuffer);

---

Building WASM from Rust: Complete Walkthrough

Rust is the dominant language for production WASM — mature toolchain, explicit memory management (no GC pauses), and excellent performance.

Step 1: Project Setup

# Install Rust and wasm toolchain
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup target add wasm32-unknown-unknown
cargo install wasm-pack
cargo install wasm-bindgen-cli

Step 2: Cargo.toml

[package]
name = "edge-utils"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]  # Required for WASM output

[dependencies]
wasm-bindgen = "0.2"
js-sys = "0.3"
serde = { version = "1", features = ["derive"] }
serde-wasm-bindgen = "0.6"

# WASM-compatible crypto (no OS RNG dependency)
sha2 = "0.10"
hex = "0.4"
base64 = "0.22"

[profile.release]
opt-level = "s"    # Optimize for size
lto = true         # Link-time optimization
codegen-units = 1  # Better optimization
panic = "abort"    # Smaller binary (no unwinding)

Step 3: Rust WASM Code

// src/lib.rs
use wasm_bindgen::prelude::*;
use sha2::{Sha256, Digest};
use serde::{Deserialize, Serialize};

// Export simple types directly
#[wasm_bindgen]
pub fn hash_sha256(input: &str) -> String {
    let mut hasher = Sha256::new();
    hasher.update(input.as_bytes());
    hex::encode(hasher.finalize())
}

#[wasm_bindgen]
pub fn base64_encode(input: &[u8]) -> String {
    use base64::Engine;
    base64::engine::general_purpose::STANDARD.encode(input)
}

// Export complex types via serde
#[derive(Serialize, Deserialize)]
pub struct ParseResult {
    pub tokens: Vec<String>,
    pub count: u32,
    pub estimated_cost_usd: f64,
}

#[wasm_bindgen]
pub fn parse_and_estimate(text: &str, cost_per_1k_tokens: f64) -> JsValue {
    let tokens: Vec<String> = text
        .split_whitespace()
        .map(String::from)
        .collect();
    let count = tokens.len() as u32;
    let estimated_cost_usd = (count as f64 / 1000.0) * cost_per_1k_tokens;

    let result = ParseResult { tokens, count, estimated_cost_usd };
    serde_wasm_bindgen::to_value(&result).unwrap()
}

// Set up panic hook for better error messages in dev
#[wasm_bindgen(start)]
pub fn main() {
    #[cfg(feature = "console_error_panic_hook")]
    console_error_panic_hook::set_once();
}

Step 4: Build and Optimize

# Build for Cloudflare Workers (bundler target)
wasm-pack build --target bundler --release

# Output in pkg/:
# edge_utils_bg.wasm       — the WASM binary
# edge_utils.js            — JavaScript glue code
# edge_utils_bg.js         — background JS
# edge_utils.d.ts          — TypeScript declarations

# Check binary size
ls -lh pkg/edge_utils_bg.wasm
# Typical: 80KB-500KB for utility functions

# Optimize with binaryen's wasm-opt
cargo install wasm-opt  # Or install from https://github.com/WebAssembly/binaryen
wasm-opt -O3 -o pkg/edge_utils_bg_opt.wasm pkg/edge_utils_bg.wasm
# wasm-opt typically reduces size 15-30% further

# Verify output is valid WASM
wasm-validate pkg/edge_utils_bg_opt.wasm

Step 5: Use in Cloudflare Worker

// src/worker.ts
import init, { hash_sha256, base64_encode, parse_and_estimate } from '../pkg/edge_utils.js';
import wasmModule from '../pkg/edge_utils_bg.wasm';

// Initialize once at module scope (runs during Worker init phase, not per request)
const wasmInitialized = init(wasmModule);

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // Ensure WASM is ready
    await wasmInitialized;

    const url = new URL(request.url);
    const action = url.searchParams.get('action');

    switch (action) {
      case 'hash': {
        const text = url.searchParams.get('text') ?? '';
        const hash = hash_sha256(text);  // ~1.5ms for 1MB input vs ~8ms JS
        return Response.json({ hash, input: text.slice(0, 50) });
      }

      case 'estimate': {
        const body = await request.json() as { text: string; costPer1k: number };
        const result = parse_and_estimate(body.text, body.costPer1k);
        return Response.json(result);
      }

      default:
        return new Response('Unknown action', { status: 400 });
    }
  }
};

---

Fastly Compute: Rust as Primary Runtime

Fastly Compute uses WASM as its execution model, making Rust the natural primary language:

// Fastly Compute: src/main.rs
use fastly::http::{Method, StatusCode};
use fastly::{Error, Request, Response};

#[fastly::main]
fn main(req: Request) -> Result<Response, Error> {
    // Route requests
    match (req.get_method(), req.get_path()) {
        (&Method::GET, "/health") => Ok(
            Response::from_status(StatusCode::OK)
                .with_body_str("OK")
        ),
        (&Method::POST, path) if path.starts_with("/api/") => {
            handle_api_request(req)
        },
        _ => Ok(
            Response::from_status(StatusCode::NOT_FOUND)
                .with_body_str("Not found")
        ),
    }
}

fn handle_api_request(req: Request) -> Result<Response, Error> {
    let body: serde_json::Value = req.take_body_json()?;
    // Process request...
    Ok(Response::from_status(StatusCode::OK)
        .with_body_json(&serde_json::json!({"ok": true}))?)
}

# Fastly CLI: deploy Rust to Compute@Edge
fastly compute build    # Compiles Rust to WASM
fastly compute deploy   # Deploys to Fastly's network (100+ PoPs)

# Cold start: <1ms (WASM isolation, not container)

---

Performance Benchmarks

Measured on Cloudflare Workers (Paid plan, ~50ms CPU budget):

Operation	JavaScript	Rust WASM	Speedup	Notes
SHA-256 hash (1MB data)	8.2ms	1.5ms	5.5x	Rust uses SIMD where available
JSON parse + validate (100KB)	2.1ms	0.8ms	2.6x	serde_json vs V8 JSON.parse
Image resize (100KB JPEG)	45ms*	9ms	5x	*Exceeds CF Free CPU budget
CSV parse (10K rows)	12ms	3.2ms	3.8x	Memory-efficient Rust iterator
Regex match (complex pattern)	1.8ms	0.4ms	4.5x	regex crate vs JS RegExp
Base64 encode (1MB)	3.2ms	0.6ms	5.3x
HTTP fetch (I/O wait)	50ms	50ms	1x	I/O bound — runtime irrelevant

Key insight: WASM significantly outperforms JS for CPU-bound tasks. For I/O-bound workloads (waiting on fetch(), KV reads), runtime choice does not matter — the bottleneck is network latency.

---

WASM Component Model and WASI 0.2

The WASM Component Model (part of WASI 0.2, standardized in 2024) defines how WASM modules from different languages interoperate. Previously, sharing types between a Rust WASM module and a JavaScript caller required manual serialization. With the Component Model:

• WIT (WASM Interface Types): Define typed interfaces once, generate bindings for any language
• Cross-language composition: A Go WASM component can call a Rust WASM component without JS glue
• Standardized syscalls: File I/O, networking, clocks — all defined in WASI interface types

// example.wit — interface definition
package example:utils@0.1.0;

interface crypto {
  hash-sha256: func(input: string) -> string;
  verify-signature: func(data: list<u8>, sig: list<u8>, key: list<u8>) -> bool;
}

world edge-utils {
  export crypto;
}

# Generate Rust bindings from WIT
cargo component build --release
# Generates a component that any WASM runtime supporting Component Model can instantiate

# Fastly Compute supports Component Model natively (WASI 0.2)
# Cloudflare Workers has partial support as of 2026

---

Limitations and When Not to Use WASM at Edge

Cannot do:

• TCP connections (edge restriction, not WASM limitation)
• File system access (edge restriction)
• Multi-threading (Workers are single-threaded; WASM threads require SharedArrayBuffer)
• Garbage collection languages without WASM GC (Swift, Java, C# — better with WASM GC proposal)
• Large memory footprints (128MB Worker limit)

When to use WASM:

• Cryptographic operations (hashing, signing, HMAC)
• Image/video processing (resize, convert, thumbnail)
• Data parsing (CSV, binary protocols, custom formats)
• Compression/decompression (gzip, zstd at edge)
• Token counting or text analysis before AI API calls
• Running existing C/C++ libraries at edge (e.g., libsodium, libyuv)

When to stick with JavaScript:

• Simple request routing and header manipulation
• JSON transformation
• Anything primarily I/O bound
• Teams without Rust experience and no performance requirement

The WASM ecosystem at the edge is mature enough for production in 2026. Start with wasm-pack and Cloudflare Workers for the best developer experience, then expand to Fastly Compute when you need maximum cold start performance or WASI 0.2 capabilities.