Running Python Greenlets in WebAssembly - Wasmer - Wasm I/O 2026

Python greenlets have been a long-standing blocker for running real Python backends on WebAssembly. In this talk, we’ll show how we were able to support Python greenlets natively with WebAssembly unlocking frameworks like SQLAlchemy on the edge and in the browser, without rewrites or async refactors.

Transcript

1. Running Python Greenlets in WebAssembly Syrus Akbary March 2026 Enabling real-world applications
2. Who am I?
3. Syrus
4. such cool WOW It’s sounds like Wasm + Docker
5. Compatibility & Speed is our obsession
6. In Wasm I/O 2024 we presented py2wasm Making Python 3x faster
8. We added support for dynamic linking in Python
9. We made Python work great in Wasmer Edge
11. But we were missing one bit…
13. What is SQLAlchemy? • It’s a popular DB ORM and toolkit for Python (320 million downloads/month) • It relies on greenlets (Green threads) heavily to not having work being blocked by DB I/O
14. What is a Greenlet?
15. Python Greenlet’s • It was the async abstraction library of Python before it had “async” “await” syntax • It allowed having non-blocking IO functions • It’s a stackful coroutine
16. WTF is a Stackful Coroutine?
17. Stackless coroutines continuations, generators, async/ await Have to be suspended from a “awaitable” function. Normally they are “embedded” into the language
18. Stackless coroutines continuations, generators, async/ await
19. Stackful coroutines f ibers, green threads, goroutines Can be suspended and resumed anywhere in the nested stack
20. Stackful coroutines f ibers, green threads, goroutines
21. Coroutines in Wasm • Stackless coroutines are trivial to run and in the generated artifacts (Wasm) • Stackful coroutines require cooperation with the JS/Wasm runtime (or operating with assembly directly)
22. How can we support stackful coroutines in the browser?
23. Making Stackful Coroutines run in the browser There are di ff erent ways to make them work: • Asyncify • Wasm Stack Switching Proposal • JS Promise Integration (JSPI)
24. Asyncify Brings Pause and Resume to WebAssembly programs Could bring “emulated” support for Stackful Coroutines. $ wasm-opt input.wasm -O1 --asyncify -o output.wasm output.wasm 1.5 bigger 2x slower
25. It slows down the whole Wasm program, and only works in “emulated” mode
26. Wasm Stack Switching Proposal The Stack Switching proposal introduces a small set of new Wasm instructions: • cont.new : creates a new continuation that can yield execution to others • cont.bind: is a monad for continuations (it returns a new function that calls the continuation with extra arguments) • suspend : it suspends the current running continuation • resume*, switch, : it invokes a suspended continuation
27. It’s experimental / not enabled in any browser
28. JS Promise Integration (JSPI) The JS Promise Integration proposal: • Had a simpler surface than the Wasm Stack Switching proposal: • WebAssembly.Suspending allows importing async functions • WebAssembly.promising allows calling wasm functions that can yield • It’s already enabled in the browsers: • Chrome has it live • Safari has it on their last preview • Firefox is implementing it
29. We decided to adopt JSPI in Wasmer API, and enable Python greenlets with it
30. We mirrored the JS Promise Integration proposal in the Wasmer Rust API, using native async syntax and without explicitly tying execution to any scheduler New Async Function API in Wasmer
31. One last thing… WASIX 🎉
32. We added a Context-switching API in WASIX To complete the design, we exposed explicit context-switch operations so WASIX programs can manage continuations directly.
33. It will work on the browser too, when using @wasmer-js/sdk
34. Demo time!
35. Thank you @syrusakbary / @wasmerio