XenonStack Recommends

Data Science

AI Simulations on Web Assembly | The Complete Guide

Dr. Jagreet Kaur Gill | 20 June 2023

AI Simulations on Web Assembly

What is WebAssembly?

WebAssembly is a project started by the World Wide Web Consortium (W3C) in 2015 to provide a standard high-performance and machine-independent byte code that is also safe. Wasm, for example, only exposes three unique isolated memory regions in terms of memory: the stack, global variables, and a linear memory region.

These regions must be reached using different type-safe instructions by design. Compiling native code makes it simple for a compiler to check that memory accesses are secure. Furthermore, high-level security policies govern other operating system resources such as networking and multi-threading management. Wasm is designed to be both fast and safe hence it uses capability-based security by default.

WASM is usually faster than JavaScript because it’s already in the binary format that the Javascript. Click to explore about, A Beginner's guide to WebAssembly

Wasm can be the target for compilation from a number of Languages, allowing it to employ features that Javascript by itself does not have access to, such as low-level memory management and so on. This approach is architectured in a pretty straightforward manner :

  • The user writes the functional code required in a language like Rust, C, C++, etc.
  • These are compiled into wasm bytes.
  • Javascript code running on Browser calls for wasm code modules.
  • The server sends back with the wasm bytes or an error.
  • The browser runs WASM where and when required.

The Web-Assembly integration can benefit a wide range of disciplines and directions. Let's have a look at two intriguing examples:

  • Edge Computing
  • AI as a Service (Node.js).

Whta is AI as a Service?

Python is the most used AI programming language nowadays. JavaScript, on the other hand, is the web programming language. We need to package AI algorithms in JavaScript, specifically Node.js, to expose AI capabilities as a web service.

However, neither Python nor JavaScript are suited for AI applications that require a lot of processing. They're high-level languages, which means they're slow and have long runtimes. Their efficiency suffers as a result of their simplicity. Python solved this problem by encapsulating AI computation in native Rust or C/C++ modules. Node.js could perform the same thing, but WebAssembly is a superior option.

Node.js and other JavaScript runtimes are tightly integrated with WebAssembly VMs. They're fast, memory-safe, secure by default and cross-platform compatible. On the other hand, our solution combines the best aspects of WebAssembly and native code.

How does WebAssembly work?

There are three pieces to the Node.js-based AI as a Service application.

  • The WebAssembly function is used by the Node.js application to conduct computationally intensive activities such as AI inference.
  • A WebAssembly function handles data preparation, post-processing, and integration with other systems. We first backed Rust. The application developer must write this function.
  • To maximise efficiency, the AI model is executed entirely in native code. This code section is only a few lines long and is checked for security and safety. App developers can use the WebAssembly code to invoke this native programme, comparable to how native methods are used in Python and Node.js today.

A face detection example

A user can upload a photo to the face detection service, displaying the image with all photos identified in green boxes. Let us refer to the Face Detection with Tensorflow Rust example from MTCNN. To make the Tensorflow library function with WebAssembly, we made some adjustments.

The Node.js application is in charge of file uploading and response. As you can see, the JavaScript app calls the infer() function with the picture data and a parameter called detection_threshold, which determines the smallest face to be detected, and then saves the return value to a server image file. The infer() function is written in Rust and compiled into WebAssembly, allowing it to be used from JavaScript.

The infer() function creates an array from the input image data. It creates a TensorFlow model and feeds the flattened image data as input. The TensorFlow model's execution returns a set of values that represent the coordinates of each face box's four corners. The infer () function draws a green box around each face before saving the altered image to the web server as a PNG file. The infer() function draws a green box around each face.

The face detection MTCNN command uses native code to execute the MTCNN TensorFlow model. Image width, image height, and detection threshold are the three arguments. The image data is supplied through STDIN from WebAssembly infer() as flattened RGB values. The model's output is encoded in JSON and sent to the STDOUT port. Notice how we used the input tensor to pass in the input picture data after passing the model parameter detection threshold to the model tensor named min size. The model's findings are retrieved using the box tensor.The objective is to construct native execution wrappers for standard AI models to be used as libraries by developers.

What is Edge Computing?

Edge computing refers to a distributed IT architecture where the customer's data is handled at the network's perimeter, as near the origin as practicable. Modern businesses rely on data to provide significant insight and real-time management over crucial business processes and operations. Large amounts of data may be routinely acquired from sensors and IoT devices running in real-time from remote places and harsh working environments practically anywhere in the world, and today's organizations are immersed in an ocean of data.

Incorporate Wasm in edge computing

WebAssembly's design encourages the creation of quick and secure programmes. Wasm removes potentially harmful elements from its execution semantics while maintaining C/C++, Rust, and other programming languages.

The automotive supply chain's fragility is one such issue. More functionality and capabilities are required in the automotive sector than ever before. However, merely adding more microprocessor-based ECUs is becoming increasingly impractical.

Instead of hiding dozens of actual computers across vehicles, automakers may now be able to share physical hardware. Lowering physical hardware requirements lowers the demand for microprocessors and lowers manufacturing costs.

Automakers can now worry less about supply chain concerns and focus on achieving their technological feats in automation, infotainment, performance, comfort, efficiency, and safety by modifying the software architecture (rather than increasing the amount of hardware necessary).


WasmEdge extends Wasm to the edge, allowing serverless functions (Wasm executables) to be integrated into various software systems. WasmEdge, for example, can be used as an API endpoint from the cloud's edge, i.e. Function as a Service (FaaS) in embedded devices, such as cars, on the Node's command line (WasmEdge Runtime, 2021)

AOT Compiler Optimizations

WasmEdge is the fastest Wasm VM on the market today in its AOT mode (WasmEdge, 2021). This is based on various Performance tests done over some time. Let us Recap a few key takeaways from some of these tests :

Test Scenario : Node.js application in Docker vs SSVM vs C/C++ native code in Docker -
  • The SSVM boots up(cold start) in less than 20 milliseconds, whereas Docker takes up to 700 milliseconds. At least 30 times faster is the SSVM.
  • Docker + native and SSVM are around 2x quicker than Docker + Node.js for computationally expensive runtime workloads.
  • Docker + native is a poor choice because it runs worse than the SSVM while sacrificing Node.js and JavaScript ecosystem benefits.

We compare a legacy stack Docker and Node.js vs the new stack of SSVM (WebAssembly). We observed a performance improvement of up to 100x times at the cold start and up to 5x at warm runtime. This does not reach the limit yet either, as there is a lot of scope for further improvement in the New SSVM stack, bettering our performance even further.

AI enables to access and manage the computing resources to train, test and deploy AI algorithms. Click to explore about, AI in IT Infrastructure Management

Possibilities with Machine Learning, Natural Language Processing and Artificial Intelligence

TensorFlow Lite on WasmEdge

TensorFlow Lite is a lightweight TensorFlow solution for embedded devices. It functions without requiring a round trip to a server because no data leaves the device, eliminating network latency and connectivity difficulties while maintaining privacy (TensorFlow Lite, 2021).

It is an open-source deep learning framework for on-device inference (TensorFlow Lite, 2021). TensorFlow Lite is able to run on smaller devices thanks to the following features:

  • Utilises less code and has fewer code dependencies making it more memory efficient.
  • It has a low-overhead static execution plan that uses flat buffers (rather than protobufs) to read data without deserializing an object has a smaller binary accepts a smaller model size has a low-overhead static execution plan.

An existing TensorFlow Frozen Graph can be used to create a TFLite file. Converting a TensorFlow model into a compressed flat buffer is how you convert a Frozen Graph to a TFLite file (with the TensorFlow Lite Converter). This strategy has been here for a while. It was, nonetheless, worth highlighting. There's excellent news for those who merely wish to use TensorFlow Lite.

Instead of going through the model conversion processes outlined above (mainly helpful in migrating). You can train, test, and execute your own TensorFlow Lite models from the ground up. The TensorFlow Lite Model Maker Library can help you with this. Let's put the TensorFlow Lite Model Maker Library to the test.

TensorFlow requires a trained model, specifically a frozen model, to accomplish object detection and facial recognition tasks. Specifically a frozen model. What do we mean by models?


GraphDef files are the nucleus of your model data; they explain your graph in a way that other processes can understand. GraphDef files are available in binary and text formats, with the.pb extension for binary and the.pbtx extension for text. The binary format is far less verbose and easier to operate on a machine than the text format, which is structured data that is also human-readable.


A TensorFlow graph's serialised variables are stored in checkpoint files. The checkpoint file has no structure; it just contains the state of the variables at various phases of the learning process.

Frozen Graph

The latest single Checkpoint file is combined with the GraphDef file to form a Frozen Graph. We take the definitions from a GraphDef file, take the values from a Checkpoint file, and then turn every variable into a constant when creating a Frozen Graph.

Java vs Kotlin
Our solutions cater to diverse industries with a focus on serving ever-changing marketing needs. Click here for our Artificial Intelligence Services


The advent of Web-Assembly in the past few years has greatly impacted the information and technology industry. It has opened up a lot of opportunities and scopes for improvement throughout the Tech stack Radar. Here, we have seen two of the many approaches that prove to be a great point of upcoming improvements, which can provide a great deal of benefits to the users and developers in terms of speed, security and access.

AI as a service is a huge upcoming area, and so is the interoperability of WASM with EDGE computing. This can be proven with the various performance benchmarking and tests done on various combinations.