What a Program Looks Like

class Item:
    def __init__(self, name: str, price: float, qty: int):
        self.name = name
        self.price = price
        self.qty = qty

    def subtotal(self) -> float:
        return self.price * self.qty


class Cart:
    def __init__(self):
        self.items = []
        self.count = 0

    def add(self, name: str, price: float, qty: int):
        item = Item(name, price, qty)
        self.items.append(item)
        self.count = self.count + 1

    def total(self) -> float:
        out: float = 0.0
        for it in self.items:
            out = out + it.subtotal()
        return out


def discount_rate(total: float) -> float:
    if total >= 100.0:
        return 0.10
    if total >= 50.0:
        return 0.05
    return 0.0


def checkout() -> float:
    cart = Cart()
    cart.add("widget", 9.99, 3)
    cart.add("gadget", 24.50, 2)
    cart.add("doohickey", 5.00, 4)
    subtotal = cart.total()
    return subtotal - subtotal * discount_rate(subtotal)

Annotations

Parameter and return annotations pick the WebAssembly value types. A collection whose elements you compare, sort, or use as dict keys needs the parameterised form: List[str], not a bare list.

Entry points

Every module-level def is exported. There is no top-level run step, so module level holds definitions only; put the code that runs in a function, or under if __name__ == "__main__":.

Imports

import mod and from mod import f resolve sibling .py files from disk and link into the one output module. No PyPI packages: the supported subset is standard-library only.

A whole program compiles in well under a millisecond and produces a few kilobytes of WebAssembly, with no interpreter or runtime bundled in: the module is the program. Optimization is where the time goes. Binaryen costs 5 to 15 times the rest of the pipeline and takes 7 to 27% off the module, so it is worth running for something you ship and worth skipping in a fast edit loop, which is what CompilerOptions { optimize: false } is for. The first three rows are the end-to-end programs above; nested_collections is the feature example with the largest module, as a second data point at a different shape.

• Module-level statements other than definitions refused workaround

  A loop, if, try, bare call, augmented assignment, or write through a subscript at module level. A WebAssembly module has no top-level run step, so the statement would be compiled away. X = 1, X = helper(), X = ClassName(), def, class, and imports do work. Move the rest into a function.

• async def, await, async for, async with refused

  There is no event loop in the output. Planned after 1.0.

• *args, **kwargs, keyword-only parameters refused

  A WebAssembly function has a fixed signature. Pass the arguments positionally.

• match, global, nonlocal, del, assert, except*, type aliases, from x import * refused

  Not implemented. Each is reported by name with its location.

• Multiple inheritance and metaclasses refused

  Single inheritance works, with super().__init__() and super().method(), plus isinstance, @dataclass, and abc.ABC.

• A subclass override reached through an inherited method differs workaround

  Dispatch is static, with no vtable. If Media.describe() calls self.kind() and Video overrides kind(), a Video still reaches Media.kind(). Calling the override directly is correct, so call it directly or override describe() too.

• Indexing, measuring, or calling a method on a lambda's parameter refused workaround

  A lambda's parameters carry no annotation, so lambda kv: kv[1] and lambda w: len(w) are refused rather than answering from an untyped word. Arithmetic and comparison are fine, so sorted(xs, key=lambda v: 0 - v) works. For anything more, use a named def, whose parameters can be annotated.

• A bare list or dict annotation workaround

  The parameterised form is what carries an element type. Write List[str] and Dict[str, int] for any collection whose elements are compared, sorted, or used as dict keys.

• Exception objects and their messages differs

  raise, try/except/finally, and propagation across calls all work. An exception carries its type, not an object: raise ValueError("msg") drops the message and except ValueError as e binds the type's code. Matching is by exact type name, plus Exception, which catches anything.

• f-string format specifiers other than .Nf refused

  f"{x:.2f}" is how a float gets printed. Widths, alignment, separators, and the !r/!a conversions are refused rather than dropped. A bare float, bool, or collection in a placeholder is also a compile error, since str() cannot render them yet.

• ** with a fractional or negative exponent differs

  Powers are computed by repeated multiplication. 2.0 ** 0.5 traps, because it needs exp/log this runtime does not carry, and a negative integer exponent traps because Python's answer is a float an int cannot hold.

• Two modules defining the same function name refused workaround

  Merged modules share one namespace, so utils.format next to report.format is a compile error naming both files. Rename one. Module-qualified names are the real fix and are not done yet.

• Object lifetime differs

  The allocator has no free: every instance lives until the module is torn down, and __del__ is never invoked. A long-running program that allocates in a loop will grow its memory.

• Set methods beyond add, remove, and discard refused

  union, intersection, and friends are not implemented. Membership, de-duplication, and the three mutators work.

• Third-party packages refused

  No PyPI. The bundled standard-library support is sys, os (including os.path), math, random, json, re, datetime, logging, collections, itertools, and functools.