WebAssembly 2025: Beyond the Browser — How Wasm Is Reshaping Server-Side, Edge, and AI Computing

;; WAT (WebAssembly Text Format) example - a function that adds two numbers
(module
  (func $add (param $a i32) (param $b i32) (result i32)
    local.get $a
    local.get $b
    i32.add
  )
  (export "add" (func $add))
)

┌──────────────────────────────────────────┐
│           Host Environment               │
│  ┌────────────┐  ┌────────────┐         │
│  │ Wasm Mod A │  │ Wasm Mod B │         │
│  │ ┌────────┐ │  │ ┌────────┐ │         │
│  │ │ Linear │ │  │ │ Linear │ │         │
│  │ │ Memory │ │  │ │ Memory │ │         │
│  │ └────────┘ │  │ └────────┘ │         │
│  └────────────┘  └────────────┘         │
│       Completely isolated from each other│
└──────────────────────────────────────────┘

// WASI Preview 1 style - file reading
use std::fs;

fn main() {
    let content = fs::read_to_string("/data/config.toml")
        .expect("Could not read file");
    println!("Config: {}", content);
}

// WIT (Wasm Interface Type) definition example
package my-app:backend;

interface http-handler {
    handle-request: func(req: request) -> response;
}

world my-server {
    import wasi:http/outgoing-handler;
    export http-handler;
}

// WASI 0.3 - Native async HTTP handler
use wasi::http::handler;

async fn handle(request: handler::Request) -> handler::Response {
    // Async database query
    let user = db::query("SELECT * FROM users WHERE id = ?", &[request.user_id]).await;

    // Async external API call
    let enriched = external_api::enrich(user).await;

    handler::Response::new(200, serde_json::to_string(&enriched).unwrap())
}

# Compose business logic written in Rust with an ML module written in Python
wasm-tools compose business-logic.wasm -d ml-module.wasm -o combined-app.wasm

# spin.toml - Spin application configuration
spin_manifest_version = 2

[application]
name = "my-api"
version = "1.0.0"

[[trigger.http]]
route = "/api/hello"
component = "hello-handler"

[component.hello-handler]
source = "target/wasm32-wasip2/release/hello_handler.wasm"
allowed_outbound_hosts = ["https://api.example.com"]

// Spin HTTP handler (Rust)
use spin_sdk::http::{IntoResponse, Request, Response};
use spin_sdk::http_component;

#[http_component]
fn handle_request(req: Request) -> anyhow::Result<impl IntoResponse> {
    let name = req
        .query()
        .get("name")
        .unwrap_or(&"World".to_string())
        .clone();

    Ok(Response::builder()
        .status(200)
        .header("content-type", "application/json")
        .body(format!(r#"{{"message": "Hello, {}!"}}"#, name))
        .build())
}

// Cloudflare Worker - Using a Wasm module
export default {
  async fetch(request, env) {
    // Image processing with a Rust-compiled Wasm module
    const wasmModule = await import('./image-processor.wasm')
    const imageData = await request.arrayBuffer()

    const processed = wasmModule.resize(
      new Uint8Array(imageData),
      800, // width
      600 // height
    )

    return new Response(processed, {
      headers: { 'Content-Type': 'image/webp' },
    })
  },
}

// Fastly Compute handler
use fastly::{Error, Request, Response};

#[fastly::main]
fn main(req: Request) -> Result<Response, Error> {
    // Geo-based routing
    let geo = req.get_client_geo().unwrap();
    let country = geo.country_code().unwrap_or("US");

    let backend = match country {
        "KR" | "JP" => "origin-apac",
        "DE" | "FR" | "GB" => "origin-eu",
        _ => "origin-us",
    };

    // Forward request to origin
    let mut beresp = req.send(backend)?;
    beresp.set_header("X-Served-By", "fastly-compute-wasm");

    Ok(beresp)
}

Question 1: Is Go your primary language?
  |-- YES -> wazero (zero external dependencies, no CGo needed)
  |-- NO
      |-- Question 2: Is latest WASI standard compliance important?
      |   |-- YES -> Wasmtime (Bytecode Alliance, standards leader)
      |   |-- NO
      |       |-- Question 3: Is AI/ML your primary workload?
      |       |   |-- YES -> WasmEdge (GGML, TensorFlow Lite integration)
      |       |   |-- NO  -> Wasmer (general purpose, wapm package manager)

HTTP "Hello World" response time (p99, microseconds):

Wasmtime:     ████████░░░░░░░░  45us
WasmEdge:     ████████░░░░░░░░  48us
Wasmer:       █████████░░░░░░░  52us
wazero:       ██████████░░░░░░  62us
Node.js:      ████████████████  120us
Docker+Node:  far beyond scale  (ms range)

// ONNX Runtime Web (Wasm backend) example
import * as ort from 'onnxruntime-web'

// Wasm backend configuration
ort.env.wasm.numThreads = 4
ort.env.wasm.simd = true

async function classifyImage(imageData) {
  const session = await ort.InferenceSession.create('mobilenet-v2.onnx', {
    executionProviders: ['wasm'],
  })

  const tensor = new ort.Tensor('float32', preprocessImage(imageData), [1, 3, 224, 224])
  const results = await session.run({ input: tensor })

  return postprocess(results.output)
}

# Running an LLM with WasmEdge
wasmedge --dir .:. \
  --nn-preload default:GGML:AUTO:llama-2-7b-chat.Q4_K_M.gguf \
  llm-chat.wasm

// LLM inference in Spin
use spin_sdk::http::{IntoResponse, Request, Response};
use spin_sdk::llm;

#[spin_sdk::http_component]
fn handle_request(req: Request) -> anyhow::Result<impl IntoResponse> {
    let prompt = req.body().as_str()?;

    let result = llm::infer(
        llm::InferencingModel::Llama2Chat,
        prompt,
    )?;

    Ok(Response::builder()
        .status(200)
        .header("content-type", "text/plain")
        .body(result.text)
        .build())
}

┌──────────────────────────────────────────────────┐
│                  User Request                     │
└─────────────┬────────────────────────────────────┘
              v
┌─────────────────────────┐
│    Edge (Wasm/Spin)      │  Auth, cache, A/B testing
│    - Microsecond resp.   │  Geo-based routing
└─────────────┬───────────┘
              v
┌─────────────────────────┐
│  Serverless (Lambda)     │  Business logic, APIs
│  - Event processing      │  DB queries, external APIs
└─────────────┬───────────┘
              v
┌─────────────────────────┐
│  Containers (ECS/K8s)    │  ML training, batch jobs
│  - Long-running tasks    │  Stateful services
└─────────────────────────┘

# Install Rust (skip if already installed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Add the Wasm target
rustup target add wasm32-wasip2

# Install Spin CLI
curl -fsSL https://developer.fermyon.com/downloads/install.sh | bash
sudo mv spin /usr/local/bin/

# Create a project with the HTTP handler template
spin new -t http-rust my-wasm-api
cd my-wasm-api

// src/lib.rs
use spin_sdk::http::{IntoResponse, Request, Response};
use spin_sdk::http_component;
use spin_sdk::key_value::Store;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct VisitorCount {
    path: String,
    count: u64,
    last_visited: String,
}

#[http_component]
fn handle_request(req: Request) -> anyhow::Result<impl IntoResponse> {
    let path = req.path().to_string();
    let method = req.method().to_string();

    match (method.as_str(), path.as_str()) {
        ("GET", "/api/health") => health_check(),
        ("GET", "/api/visitors") => get_visitor_count(&path),
        ("POST", "/api/visitors") => increment_visitor(&path),
        _ => Ok(Response::builder()
            .status(404)
            .body("Not Found")
            .build()),
    }
}

fn health_check() -> anyhow::Result<impl IntoResponse> {
    Ok(Response::builder()
        .status(200)
        .header("content-type", "application/json")
        .body(r#"{"status": "healthy", "runtime": "wasm"}"#)
        .build())
}

fn get_visitor_count(path: &str) -> anyhow::Result<impl IntoResponse> {
    let store = Store::open_default()?;
    let count = store
        .get(path)
        .map(|bytes| String::from_utf8(bytes).unwrap_or_default())
        .unwrap_or_else(|| "0".to_string());

    Ok(Response::builder()
        .status(200)
        .header("content-type", "application/json")
        .body(format!(r#"{{"path": "{}", "count": {}}}"#, path, count))
        .build())
}

fn increment_visitor(path: &str) -> anyhow::Result<impl IntoResponse> {
    let store = Store::open_default()?;
    let current: u64 = store
        .get(path)
        .map(|bytes| String::from_utf8(bytes).unwrap_or_default())
        .unwrap_or_else(|| "0".to_string())
        .parse()
        .unwrap_or(0);

    let new_count = current + 1;
    store.set(path, new_count.to_string().as_bytes())?;

    Ok(Response::builder()
        .status(200)
        .header("content-type", "application/json")
        .body(format!(r#"{{"path": "{}", "count": {}}}"#, path, new_count))
        .build())
}

# Build
spin build

# Run locally
spin up

# Test from another terminal
curl http://localhost:3000/api/health
# Output: {"status": "healthy", "runtime": "wasm"}

curl -X POST http://localhost:3000/api/visitors
# Output: {"path": "/api/visitors", "count": 1}

curl http://localhost:3000/api/visitors
# Output: {"path": "/api/visitors", "count": 1}

# Log in to Fermyon Cloud
spin cloud login

# Deploy
spin cloud deploy

# Example output:
# Uploading my-wasm-api version 1.0.0...
# Deploying...
# Application deployed!
# URL: https://my-wasm-api-xyz123.fermyon.app

Build artifact sizes:
  Wasm binary:           247 KB
  Node.js (node_modules): 45 MB
  Go binary:             8.2 MB
  Docker image (Node):   145 MB
  Docker image (Alpine): 52 MB

// Rust - Full WASI 0.2 support
use std::io::Write;

fn main() {
    let mut stdout = std::io::stdout();
    writeln!(stdout, "Hello from Rust + Wasm!").unwrap();
}

# Compile
cargo build --target wasm32-wasip2 --release
# Run
wasmtime target/wasm32-wasip2/release/my-app.wasm

// C - Compile with Emscripten or wasi-sdk
#include <stdio.h>

int main() {
    printf("Hello from C + Wasm!\n");
    return 0;
}

# Compile with wasi-sdk
/opt/wasi-sdk/bin/clang hello.c -o hello.wasm
wasmtime hello.wasm

// Go - Wasm compilation with TinyGo
package main

import "fmt"

func main() {
    fmt.Println("Hello from Go + Wasm!")
}

# Compile with TinyGo (standard Go also adding WASI support)
tinygo build -target=wasip2 -o hello.wasm main.go
wasmtime hello.wasm

// C# - .NET 8+ Wasm support
using System;

class Program {
    static void Main() {
        Console.WriteLine("Hello from C# + Wasm!");
    }
}

# Build with .NET 8 WASI workload
dotnet workload install wasi-experimental
dotnet build -c Release
wasmtime bin/Release/net8.0/wasi-wasm/my-app.wasm

# Python - Wasm conversion via componentize-py
# Still experimental but rapidly improving

def handle_request(request):
    return {
        "status": 200,
        "body": f"Hello from Python + Wasm!"
    }

# Create Wasm component with componentize-py
componentize-py -d wit/ -w my-world componentize app -o app.wasm

// JavaScript - StarlingMonkey (SpiderMonkey-based) or javy
export function handleRequest(request) {
  return {
    status: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ message: 'Hello from JS + Wasm!' }),
  }
}

Adoption curve:

  Innovators    Early Adopters    Early Majority    Late Majority    Laggards
  (2019)        (2022)           (2025)            (2027?)          (2030?)
    |              |          <<<HERE>>>              |                |
    v              v              v                   v                v
  +--+        +--------+    +----------+
  |  |        |        |    |          |
  |  |        |        |    |  HERE!   |
  +--+        +--------+    +----------+
  Wasm MVP    WASI P1       WASI 0.2/0.3
  Browser     Server exp.   Production deploy