A Bytecode Alliance project

This is a tool to convert a Python application to a WebAssembly component. It 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 which targets said world
• a list of directories in which to find the Python module and its dependencies

The output is a component which may be run using e.g. wasmtime.

First, install Python 3.10 or later and pip if you don't already have them. Then, install componentize-py:

pip install componentize-py

Next, create or download the WIT world you'd like to target, e.g.:

cat >hello.wit <<EOF
package example:hello;
world hello {
  export hello: func() -> string;
}
EOF

If you're using an IDE or just want to examine the bindings produced for the WIT world, you can generate them using the bindings subcommand:

componentize-py -d hello.wit -w hello bindings hello_guest

Then, use the bindings produced by the command above (a wit package inside hello_guest) to write your app:

cat >app.py <<EOF
import wit

@wit.guest
class Hello(wit.WorldExports):
    def hello(self) -> str:
        return "Hello, World!"
EOF

And finally generate the component:

componentize-py -d hello.wit -w hello componentize --stub-wasi app -o app.wasm

An exact, versioned world can also be loaded from a WebAssembly package registry:

componentize-py -w wasi:cli/[email protected] bindings wasi_cli

Use --registry-config PATH to merge a standard wasm-pkg configuration file with the global configuration. Use --no-default-registries to start with an empty configuration before loading that file. Registry loading is lazy, and a matching local WIT definition takes precedence. Remote world references must use the exact namespace:package/world@version form.

To test it, you can install wasmtime-py and write a simple host app which uses it to load and run our component:

pip install wasmtime==48.0.0
cat >host.py <<EOF
from wasmtime import Config, Engine, Store
from wasmtime.component import Component, Linker

config = Config()
config.cache = True
engine = Engine(config)
store = Store(engine)
component = Component.from_file(engine, "app.wasm")
linker = Linker(engine)
instance = linker.instantiate(store, component)
hello = instance.get_func(store, "hello")
print(f"component says: {hello(store)}")
EOF

And then run it:

 $ python3 host.py
component says: Hello, World!

See the examples directories for more examples, including various ways to run the components you've created.

Currently, the application can only import dependencies during build time, which means any imports used at runtime must be resolved at the top level of the application module. For example, if x is a module with a submodule named y the following may not work:

import x

class Hello(hello.Hello):
    def hello(self) -> str:
        return x.y.foo()

That's because importing x does not necessarily resolve y. This can be addressed by modifying the code to import y at the top level of the file:

from x import y

class Hello(hello.Hello):
    def hello(self) -> str:
        return y.foo()

This limitation is being tracked as issue #23.

See the issue tracker for other known issues.

See CONTRIBUTING.md for details on how to contribute to the project and build it from source.