WebAssembly System Interface (WASI) Explained

What is WASI?

WASI is an API specification designed for WebAssembly modules to communicate with the host environment while maintaining security and portability. It provides access to essential system functionalities like file systems, sockets and clocks without compromising WebAssembly’s sandboxed nature.

Key Features of WASI:

Platform Independence: Write once, run anywhere.
Secure by Default: Sandboxed execution with explicit access permissions.
Modular Design: Can be extended for specific use cases or platforms.
Non-Browser Environments: Runs on servers, IoT devices or any environment with a Wasm runtime.

Why WASI is Important

WebAssembly was initially designed for the web, limiting its functionality to browser-based tasks. WASI expands its scope by providing the following advantages:

Universal Applications: Enables WebAssembly to run on servers and desktops without modification.
Security: Ensures a secure interaction between applications and the host OS.
Simplified Deployment: Eliminates platform-specific dependencies.
Ecosystem Growth: Supports languages and tools to build robust cross-platform applications.

Core Concepts of WASI

1. Sandboxed Environment

WASI modules operate in a controlled environment with restricted access to system resources. Permissions must be explicitly granted by the host.

2. Capability-Based Security

Applications must request access to specific resources (e.g., files, sockets), ensuring they cannot access anything outside the allowed scope.

3. Modular Design

WASI is split into several modules for functionalities like I/O, networking and clocks. Developers can use only the required modules, optimizing performance.

Setting Up WASI

Prerequisites:

Node.js: For working with Wasm runtimes.
Wasm Runtime: Install a WASI-compatible runtime like Wasmtime or WasmEdge.

Installation:

Install Wasmtime:

curl https://wasmtime.dev/install.sh -sSf | bash

Verify installation:

wasmtime --version

Writing a WASI-Compatible Module

Let’s create a WebAssembly module using Rust that reads and prints a file.

Step 1: Install Rust and WebAssembly Target

Install Rust if it’s not already installed:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Add the WebAssembly target:

rustup target add wasm32-wasi

Step 2: Create the Rust Project

Create a new Rust project:

cargo new wasi-example
cd wasi-example

Edit Cargo.html to specify the WebAssembly target:

[lib]
crate-type = ["cdylib"]

[dependencies]

Step 3: Write the Rust Code

Edit src/lib.rs to add the following code:

use std::fs;
use std::io::{self, Write};

#[no_mangle]
pub extern "C" fn read_file() {
    let path = "example.txt";

    // Read the file
    match fs::read_to_string(path) {
        Ok(content) => {
            println!("File content:\n{}", content);
        }
        Err(e) => {
            eprintln!("Error reading file: {}", e);
        }
    }
}

Step 4: Compile the Code

Compile the Rust code into WebAssembly:

cargo build --target wasm32-wasi --release

Step 5: Run the WASI Module

Create a sample file:

echo "Hello, WASI!" > example.txt

Run the Wasm module using Wasmtime:

wasmtime target/wasm32-wasi/release/wasi_example.wasm --dir=.

Output:

File content:
Hello, WASI!

Advanced WASI Features

1. File System Operations

WASI supports file operations like reading, writing, and directory traversal.

Example:

use std::fs;

pub fn create_file() {
    fs::write("new_file.txt", "WASI Rocks!").expect("Unable to write file");
}

2. Networking

Networking is in experimental phases but allows basic socket operations using extended WASI runtimes like WasmEdge.

3. Environment Variables

WASI modules can access environment variables using system calls.