Skip to content
πŸπŸ•Έ Python library to run WebAssembly binaries.
Branch: master
Clone or download
Latest commit 1c5d2ec Apr 19, 2019
Type Name Latest commit message Commit time
Failed to load latest commit information.
.circleci chore(ci) Set up Bors. Apr 18, 2019
benchmarks test(benchmarks) Lower `N`. Apr 13, 2019
examples fix(examples) Remove a useless import. Apr 14, 2019
tests test(memory) Add more tests for memory views `__getitem__`. Apr 14, 2019
.gitattributes Create .gitattributes Apr 16, 2019
.gitignore test(benchmarks) Add benchmarks. Apr 13, 2019
Cargo.lock chore(release) Bump version. Apr 15, 2019
Cargo.toml chore(release) Bump version. Apr 15, 2019 Improve download link Apr 16, 2019
bors.toml chore(ci) Set up Bors. Apr 18, 2019
justfile chore(just) Run `prelude` and `wakeup` in Bash. Apr 15, 2019
rust-toolchain feat(extension) Partially replace `rust-cypthon` by `pyo3`. Apr 12, 2019

Wasmer logo Β  Join the Wasmer Community Pypi License

Wasmer is a Python library for executing WebAssembly binaries:

  • Easy to use: The wasmer API mimics the standard WebAssembly API,
  • Fast: wasmer executes the WebAssembly modules at native speed,
  • Safe: All calls to WebAssembly will be fast, but more importantly, completely safe and sandboxed.


To install the wasmer Python library, just run this command in your shell:

$ pip install wasmer

Note: There is a limited set of wheels published so far. More are coming.

View the wasmer on Pypi.


There is a toy program in examples/, written in Rust (or any other language that compiles to WebAssembly):

pub extern fn sum(x: i32, y: i32) -> i32 {
    x + y

After compilation to WebAssembly, the examples/simple.wasm binary file is generated. (Download it).

Then, we can excecute it in Python:

from wasmer import Instance

wasm_bytes = open('simple.wasm', 'rb').read()
instance = Instance(wasm_bytes)
result = instance.exports.sum(5, 37)

print(result) # 42!

And then, finally, enjoy by running:

$ python examples/

API of the wasm extension/module

The Instance class

Instantiates a WebAssembly module represented by bytes, and calls exported functions on it:

from wasmer import Instance

# Get the Wasm module as bytes.
wasm_bytes = open('my_program.wasm', 'rb').read()

# Instantiates the Wasm module.
instance = Instance(wasm_bytes)

# Call a function on it.
result = instance.exports.sum(1, 2)

print(result) # 3

All exported functions are accessible on the exports getter. Arguments of these functions are automatically casted to WebAssembly values. If one wants to explicitely pass a value of a particular type, it is possible to use the Value class, e.g. instance.exports.sum(Value.i32(1), Value.i32(2)). Note that for most usecases, this is not necessary.

The memory getter exposes the Memory class representing the memory of that particular instance, e.g.:

view = instance.memory.uint8_view()

See below for more information.

The Value class

Builds WebAssembly values with the correct types:

from wasmer import Value

# Integer on 32-bits.
value_i32 = Value.i32(7)

# Integer on 64-bits.
value_i64 = Value.i64(7)

# Float on 32-bits.
value_f32 = Value.f32(7.42)

# Float on 64-bits.
value_f64 = Value.f64(7.42)

The Value.[if](32|64) static methods must be considered as static constructors.

The __repr__ method allows to get a string representation of a Value instance:

print(repr(value_i32)) # I32(7)

The Memory class

A WebAssembly instance has its own memory, represented by the Memory class. It is accessible by the Instance.memory getter.

The Memory class offers methods to create views of the memory internal buffer, e.g. uint8_view, int8_view, uint16_view etc. All these methods accept one argument: offset, to subset the memory buffer at a particular offset. These methods return respectively a *Array object, i.e. uint8_view returns a Uint8Array object etc.

offset = 7
view = instance.memory.uint8_view(offset)


The *Array classes

These classes represent views over a memory buffer of an instance.

Class View buffer as a sequence of… Bytes per element
Int8Array int8 1
Uint8Array uint8 1
Int16Array int16 2
Uint16Array uint16 2
Int32Array int32 4
Uint32Array uint32 4

All these classes share the same implementation. Taking the example of Uint8Array, the class looks like this:

class Uint8Array:
    def bytes_per_element()

    def __len__()
    def __getitem__(index|slice)
    def __setitem__(index, value)

Let's see it in action:

from wasmer import Instance

# Get the Wasm module as bytes.
wasm_bytes = open('my_program.wasm', 'rb').read()

# Instantiates the Wasm module.
instance = Instance(wasm_bytes)

# Call a function that returns a pointer to a string for instance.
pointer = instance.exports.return_string()

# Get the memory view, with the offset set to `pointer` (default is 0).
memory = instance.memory.uint8_view(pointer)

# Read the string pointed by the pointer.
nth = 0;
string = ''

while True:
    char = memory[nth]
    if char == 0:

    string += chr(char)
    nth += 1

print(string) # Hello, World!

A slice can be used as index of the __getitem__ method, which is useful when we already know the size of the data we want to read, e.g.:

print(''.join(map(chr, memory[0:13]))) # Hello, World!

Notice that *Array treat bytes in little-endian, as required by the WebAssembly specification, Chapter Structure, Section Instructions, Sub-Section Memory Instructions:

All values are read and written in little endian byte order.

Each view shares the same memory buffer internally. Let's have some fun:

int8 = instance.memory.int8_view()
int16 = instance.memory.int16_view()
int32 = instance.memory.int32_view()

int8[0] = 0b00000001
int8[1] = 0b00000100
int8[2] = 0b00010000
int8[3] = 0b01000000

// No surprise with the following assertions.
assert int8[0] == 0b00000001
assert int8[1] == 0b00000100
assert int8[2] == 0b00010000
assert int8[3] == 0b01000000

// The `int16` view reads 2 bytes.
                        bβ‚‚       b₁
                     β”Œβ”¬β”¬β”¬β”¬β”¬β”¬β” β”Œβ”¬β”¬β”¬β”¬β”¬β”¬β”
assert int16[0] == 0b00000100_00000001
                        bβ‚„       b₃
                     β”Œβ”¬β”¬β”¬β”¬β”¬β”¬β” β”Œβ”¬β”¬β”¬β”¬β”¬β”¬β”
assert int16[1] == 0b01000000_00010000

// The `int32` view reads 4 bytes.
                        bβ‚„       b₃       bβ‚‚       b₁
                     β”Œβ”¬β”¬β”¬β”¬β”¬β”¬β” β”Œβ”¬β”¬β”¬β”¬β”¬β”¬β” β”Œβ”¬β”¬β”¬β”¬β”¬β”¬β” β”Œβ”¬β”¬β”¬β”¬β”¬β”¬β”
assert int32[0] == 0b01000000_00010000_00000100_00000001;

The validate function

Checks whether the given bytes represent valid WebAssembly bytes:

from wasmer import validate

wasm_bytes = open('my_program.wasm', 'rb').read()

if not validate(wasm_bytes):
    print('The program seems corrupted.')

This function returns a boolean.


The Python extension is written in Rust, with rust-cpython and pyo3-pack.

To set up your environment, run only once:

$ just prelude

It will install pyo3-pack for Python and for Rust. It will also install virtualenv.

Then, simply run:

$ .env/bin/activate
$ just rust
$ just python-run examples/

If you need to interact with Python, or run a specific file, use the following commands:

$ just python-run
$ just python-run file/to/

Finally, to inspect the extension; run:

$ just inspect

(Yes, you need just).


Once the extension is compiled and installed (just run just rust), run the following command:

$ just test

What is WebAssembly?

Quoting the WebAssembly site:

WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable target for compilation of high-level languages like C/C++/Rust, enabling deployment on the web for client and server applications.

About speed:

WebAssembly aims to execute at native speed by taking advantage of common hardware capabilities available on a wide range of platforms.

About safety:

WebAssembly describes a memory-safe, sandboxed execution environment […].


The entire project is under the BSD-3-Clause license. Please read the LICENSE file.

You can’t perform that action at this time.