WebAssembly SIMD support

This guide explains WebAssembly single instruction, multiple data (SIMD) support, how to detect browser compatibility, common errors, and fallback strategies when using Nutrient Web SDK.

What is WebAssembly SIMD?

WebAssembly SIMD is an extension to WebAssembly that enables parallel processing of data using vector instructions. Nutrient Web SDK uses SIMD to improve performance for operations such as PDF rendering and document export.

For more information on WebAssembly in Nutrient, refer to our WebAssembly: A new hope blog.

Browser support

The following table shows the minimum browser versions required for WebAssembly SIMD support in Nutrient Web SDK-supported browsers.

Browser	Minimum version for SIMD
Chrome	91
Firefox	89
Edge	91
Safari	16.4
Safari iOS	16.4
Chrome Android	91
Firefox Android	89

Unsupported environments

The following environments don’t support WebAssembly SIMD:

Internet Explorer (all versions)
Edge Legacy (EdgeHTML-based, versions 18 and earlier)
Safari and Safari iOS versions earlier than 16.4
CPUs without SIMD instruction support (for example, some AMD Phenom processors)

For the full list of Nutrient Web SDK-supported browsers, refer to the browser support guide.

Feature detection

Detect WebAssembly SIMD support before initializing the SDK or performing export operations. You have the following options.

Using the wasm-feature-detect library

The wasm-feature-detect(opens in a new tab) library is an npm package that detects which WebAssembly features are supported in the current browser, including SIMD.

Install the library:

npm install wasm-feature-detect

Detect SIMD support:

import { simd } from "wasm-feature-detect";

async function checkSIMDSupport() {
  const simdSupported = await simd();

  if (simdSupported) {
    console.log("SIMD is supported");
  } else {
    console.log("SIMD is not supported");
  }

  return simdSupported;
}

Inline detection without dependencies

Use the following function to detect SIMD support without external dependencies:

function detectSIMDSupport() {
  try {
    // This byte sequence represents a minimal WebAssembly module
    // that uses SIMD instructions (i32x4.splat and i8x16.swizzle).
    return WebAssembly.validate(
      new Uint8Array([
        0, 97, 115, 109, // Magic number (\0asm)
        1, 0, 0, 0,      // Version 1
        1, 5, 1, 96,     // Type section
        0, 1, 123,       // Function type returning v128
        3, 2, 1, 0,      // Function section
        10, 10, 1, 8,    // Code section
        0, 65, 0,        // i32.const 0
        253, 15,         // i32x4.splat (SIMD prefix 0xfd)
        253, 98,         // i8x16.swizzle
        11               // end
      ])
    );
  } catch (e) {
    return false;
  }
}

if (detectSIMDSupport()) {
  console.log("SIMD supported");
} else {
  console.log("SIMD not supported");
}

Common errors

Error — err_export_wasm_simd_not_supported
Cause — The browser or environment doesn’t support WebAssembly SIMD instructions, and an export operation requiring SIMD failed.
Common scenarios
- User is on an older browser version.
- User is on a smart TV browser (Samsung Tizen, LG WebOS).
- User’s CPU doesn’t support SIMD instructions.
- Microsoft Edge has Enhanced Security Mode enabled.
Solution — Implement feature detection before attempting export operations, and provide appropriate user messaging.
Error — CompileError: WebAssembly.instantiateStreaming(): Compiling function failed: Invalid opcode 0xfd (enable with --experimental-wasm-simd)
Cause — The browser encountered the SIMD opcode prefix (0xfd) but doesn’t support SIMD instructions.
Solution — This error appears in older browser versions. Prompt users to update their browser.
Error — LinkError: WebAssembly.instantiate() with SIMD modules
Cause — The browser compiled the WebAssembly module successfully but failed to link it due to missing SIMD support at the environment level.
Solution — Use feature detection before loading SIMD-enabled modules.
Error — RuntimeError during SIMD operations
Cause — The browser executed SIMD instructions but they failed at runtime due to:
- Memory alignment issues
- Out-of-bounds vector access
- Browser-specific SIMD implementation bugs
Solution — Verify you’re using a supported browser version and report persistent issues to support.
Error — TypeError: Failed to parse URL or no available backend found
Cause — The WebAssembly loader couldn’t find a compatible backend (neither SIMD nor fallback).
Solution — Verify you deployed the SDK assets correctly and they’re accessible.

Fallback strategies

Graceful degradation with user notification

Check SIMD support before attempting export operations:

async function exportDocument(instance, options) {
  if (!detectSIMDSupport()) {
    return {
      success: false,
      error: "export_not_supported",
      message:
        "Document export requires a browser with WebAssembly SIMD support. " +
        "Use Chrome 91+, Firefox 89+, Safari 16.4+, or Edge 91+."
    };
  }

  try {
    const pdf = await instance.exportPDF(options);
    return { success: true, data: pdf };
  } catch (error) {
    if (error.message.includes("simd") || error.message.includes("SIMD")) {
      return {
        success: false,
        error: "simd_error",
        message: "Export failed due to WebAssembly compatibility. Update your browser."
      };
    }
    throw error;
  }
}

Server-side fallback

Route export operations to a server when the client doesn’t support SIMD:

async function exportWithFallback(instance, documentId, options) {
  if (detectSIMDSupport()) {
    try {
      return await instance.exportPDF(options);
    } catch (error) {
      console.warn("Client-side export failed, falling back to server:", error);
    }
  }

  // Fallback to server-side export.
  const response = await fetch("/api/export", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ documentId, options })
  });

  if (!response.ok) {
    throw new Error("Server-side export failed");
  }

  return await response.blob();
}

For server-side processing, refer to our Document Engine guide.

Preinitialization compatibility check

Check browser compatibility before loading the SDK:

async function initializeNutrient(config) {
  const compatibility = checkBrowserCompatibility();

  if (!compatibility.supported) {
    showCompatibilityMessage(compatibility.reason);
    return null;
  }

  return await NutrientViewer.load(config);
}

function checkBrowserCompatibility() {
  if (typeof WebAssembly === "undefined") {
    return {
      supported: false,
      reason: "Your browser doesn't support WebAssembly."
    };
  }

  if (!detectSIMDSupport()) {
    return {
      supported: false,
      reason: "Your browser doesn't support WebAssembly SIMD. Update to a modern browser version.",
      minimumVersions: {
        Chrome: "91+",
        Firefox: "89+",
        Safari: "16.4+",
        Edge: "91+"
      }
    };
  }

  return { supported: true };
}

When to contact Support

Contact Nutrient Support at support@nutrient.io when you encounter:

SIMD errors on supported browsers — Errors such as err_export_wasm_simd_not_supported on Chrome 91+, Firefox 89+, Safari 16.4+, or Edge 91+ indicate a potential SDK issue.
Consistent export failures — Exports fail consistently across multiple supported browsers with the same error.
New error patterns after SDK update — SIMD-related errors start appearing after updating to a new SDK version.

Information to include

When contacting Support, provide:

Browser and version (for example, Chrome 120.0.6099.109)
Operating system (for example, Windows 11, macOS 14.2)
SDK product and version (for example, Nutrient Web SDK 2024.1.0)
Full error message from console or error tracking service
Stack trace if available
Minimal steps to reproduce the issue
Output of detectSIMDSupport() function

Self-service solutions

Before contacting Support, try the following:

Verify the browser version meets minimum requirements.
Test in an incognito or private window to rule out extensions.
Test on a different device or browser.
Clear the browser cache and reload.
Check if Edge Enhanced Security Mode is disabled.
Verify the SDK assets load correctly (check for 404 errors in the Network tab).