Write Python. Run Wasm.

You don’t just accidentally fall into implementing WebAssembly (Wasm). There is a lot to learn and it takes time. For example, the current Wasm specification document spans three hundred pages.

We inevitably want to achieve wide adoption of Wasm. But how?

Let's start by focusing on Python. The most recent GitHub Octoverse report (2024) indicates that Python outranks all other programming languages by the count of distinct users contributing to projects.

Converting a Python application to a WebAssembly component can be achieved via the Bytecode Alliance’s componentize-py project. Great! But wait there’s more …

The componentize-py tool takes the following as input:

• a WIT file or directory,

• the name of a WIT world defined in the above file or directory,

• the name of a Python module that targets said world, and

• a list of directories in which to find the Python module and its dependencies.

Right out of the gate, we are already burdened with extra work. What is a WIT file and a WIT world and so on?

The reality is we resort to the effort-to-reward ratio where we either:

• just hack something together for now (low effort and reasonably low reward, or

• just don’t use Wasm (low effort and low reward).

If we want the high effort and high reward, we end up back in a loop where we need to read the 300-page Wasm specification, and the Wasm Component Model documentation site at the least. And, if your original goal was just to write Python and run Wasm you are a long way from home and probably over time and over budget on whichever project you wanted to integrate with Wasm.

But don’t be disparaged. The payoff for structuring Wasm correctly is huge. Let’s spend the rest of this article figuring out a solution to this conundrum.

The work on Wasm is going brilliantly and we need to trust that the component model with all of its WIT and World “stuff” is the correct path forward. Because it is! But I digress. Let’s continue brainstorming how to provide a way where developers can simply:

• Write Python, and

• Run Wasm?

Consider this automatic WIT generation code that will generate the WIT file automatically based on the Python code — sticking with the ethos of Write Python. Run Wasm.

If we create a file called generate_wit.py and populate it with the following Python this could be a starting point for:

• automatically creating WIT files from native Python,

• automatically running componentize-py with said WIT file[s], and

• executing our native Python as Wasm.

The following script opens the door to new tooling converts native Python code to WebAssembly components and then runs them (without the developer requiring any knowledge of WIT files):

import ast
import inspect
from typing import List

def generate_wit_from_python(source_code, filename="auto_generated.wit"):
    # Parse the source code into an AST
    tree = ast.parse(source_code)

    functions = []
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name not in ['__main__', 'main']:
            func_name = node.name
            args = []
            for arg in node.args.args:
                args.append(arg.arg)

            # Assume all returns are of type 'i32' for simplicity. 
            # In a more complete implementation, you'd infer or ask for the return type.
            returns = 'i32'  

            # Function signature in WIT syntax. Here, we assume all arguments are i32, 
            # which is a simplification. A more nuanced approach would require type mapping.
            func_signature = f"{func_name}: func({', '.join([f'{arg}: i32' for arg in args])}) -> {returns}"
            functions.append(func_signature)

    # Generate WIT file content
    wit_content = """package auto_generated;

interface auto_interface {
"""
    for func in functions:
        wit_content += f"    {func}\n"
    wit_content += """}

world auto_world {
    export auto_interface;
}
"""

    # Write WIT to file
    with open(filename, 'w') as f:
        f.write(wit_content)

# Example usage
if __name__ == "__main__":
    with open('example.py', 'r') as file:
        python_code = file.read()
    generate_wit_from_python(python_code, "example.wit")
    print(f"WIT file 'example.wit' has been generated!")

    # Run componentize-py command
    import subprocess
    subprocess.run(["componentize-py", "example.py", "example.wit", "-o", "example.wasm"])
    print(f"Wasm file 'example.wasm' has been compiled!")

    # Run the resulting Wasm file with wasmtime
    subprocess.run(["wasmtime", "example.wasm"])

This script makes a few assumptions (you’d need a more sophisticated type inference) to correctly map to Wasm types.

The script “as-is” generates a generic package name (auto_generated), interface name (auto_interface), and world name (auto_world).

You will notice that the script is just slurping up arbitrary files i.e. example.py from the file system (which is fine for now). A production tool could perhaps have a structured configuration mechanism that would target a series of Python files in a hierarchical directory structure.

More robust type mapping would be great (and most of the heavy lifting that I am prepared to do if there is interest); the idea is to enable developers to simply “Write Python. Run Wasm”.

If you have any questions or comments please email me at mistermac2008@gmail.com. I am also on https://x.com/mistermac2008 and GitHub.

Photo by Brecht Corbeel on Unsplash