LUluu·Oct 4, 2026Submission
wizard-engine: Research WebAssembly Engine
1 points · Open discussiontitzer
wizard-engine
WebAssembly2021–2026
titzer / wizard-engine
wizard-engine
Research WebAssembly Engine
9Distinct people
14Mentions
0Explicit recommenders
515GitHub stars
What to know before exploring
What it is
Research WebAssembly Engine
GitHub
Where it is used
No documented product use has been verified yet.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 12:54:37 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year14 dated mentions
Observed mentions: 2021-07-28 20:57:36 UTC to 2026-10-04 05:11:16 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 1 | 1 | 0 |
What Hacker News says
14 sourcesThe Wizard Engine: A WASM virtual machine for research and teaching
2 points · Open discussion> Don't ever use inheritance. Instead of things inheriting from other things, flip the relationship and make things HAVE other things. This is called composition and it has all the positives of inheritance but none of the negatives.
Bah. There are completely legitimate uses of inheritance where it's a really great fit. I think you'll find that being dogmatic about avoiding a programming pattern will eventually get you twisted up in other ways.
Inheritance can be used in a couple of ways that achieve a very-specific kind of code reuse. While I went through the early 2000's Java hype cycle with interfaces and factories and builders and double-dispatch and visitors everywhere, I went through a period where I hated most of that crap and swore to never use the visitor pattern again.
But hey, within the past two years I found an unbeatable use
Read the rest
case where the visitor pattern absolutely rocks (it's there: https://github.com/titzer/wizard-engine/blob/master/src/util...). If you can come up with another way by which you can deal with 550 different kinds of animals (the Wasm instructions) and inherit the logic for 545 and just override the logic for 5 of them, then be my guest. (And yes, you can use ADTs and pattern-matching, which I do, liberally--but the specifics of how immediates and their types are encoded and decoded just simply cannot be replicated with as little code as the visitor pattern).
So don't completely swear off inheritance. It's like saying you'll never use a butter knife because you only do pocket knives. After all, butter knives are dull and not good for anything but butter.
There is also this (https://github.com/mbbill/Silverfir) and Wizard (https://github.com/titzer/wizard-engine).
I wrote a paper about Wizard's in-place interpreter and benchmarked lots of runtimes in (https://dl.acm.org/doi/abs/10.1145/3563311).
As there seem to be even more runtimes popping up (great job with wasmi, btw), it seems like a fun, maybe even full-time, job to keep up with them all.
In Wasmi v0.32: WebAssembly interpreter is now faster than everShow HN: WebAssembly Instrumentation in the Wizard Research Engine
Hello all,
I've been working on research tools for Wasm for some time now, and just today we put up the pre-print for our newest paper "Flexible Non-intrusive Dynamic Instrumentation for WebAssembly" (https://arxiv.org/abs/2403.07973), which will appear in ASPLOS 2024. Two previous papers, one about Wizard's interpreter (https://dl.acm.org/doi/10.1145/3563311) and one about the JIT (https://arxiv.org/abs/2305.13241) have been discussed on HN before.
This new paper explains what Wizard is really about: dynamic instrumentation of Wasm programs, without modifying the program or its behavior. Wizard can do this with a flexible callback API (probes) that are supported, and indeed optimized, in all of Wizard's execution tiers.
We'd be interested in more feedback, more people kicking the tires, and ideas for more dynamic analyses that can be bui
Read the rest
lt through its APIs. It's pretty easy to write a new monitor that instruments and studies programs; this is what we expect people will want to do very often. And of course we'd welcome contributions of useful monitors back to Wizard's repo.
(This post is also part apology in that I suck at marketing and documentation--I'm deep in compilers most of the time!).
I think I would like the former syntax. Witness one of the several nested matching situations I run into:
https://github.com/titzer/wizard-engine/blob/master/src/engi...
This would be much, much better if Virgil had pattern matching on tuples of ADTs.
In Push ifs up and fors downWe're inspired by this project, linking for posterity: https://github.com/titzer/wizard-engine
In Observability in WebAssemblyMore info on Github: https://github.com/titzer/wizard-engine
In Whose baseline (compiler) is it anyway?Congrats to the Wasmtime team on the 1.0 release!
I'm happy to see that more runtimes are maturing and getting use on production cases... I can't wait to see and show what the future entails for WebAssembly on both the server side and the browser!
Keep up the good work. Also I'd like to use this message to congratulate other runtimes that I'm excited about (apart from Wasmer, of course!): Wizard Engine [1], Wazero [2] and Lunatic [3].
The future is bright in Wasm land :)
[1] https://github.com/titzer/wizard-engine
[2] https://github.com/tetratelabs/wazero
[3] https://github.com/lunatic-solutions/lunatic
In Wasmtime 1.0I discovered this project when I was taking a look on Wizard, a fast and low-resource Wasm interpreter [1].
One of the things that excites me about Virgil is that is completely self-hosted (the runtime is fully implemented in Virgil, and it can compile itself).
Curiously enough, the person that created Virgil (programming language) and Wizard (Wasm runtime) was Ben L. Titzer, who worked on the V8 team at Google and co-created Wasm. I'm pretty excited with what he can bring to the table :)
Update: I'm trying to have virgil to self-compile into Wasm/WASI, and will try to upload it to WAPM [2] so everyone can use it easily (as the first compilation of v3c currently requires the JVM)... stay tuned!
[1]: https://github.com/titzer/wizard-engine
[2]: https://wapm.io/
In Virgil: A fast and lightweight programming language that compiles to WASMWizard: An advanced WebAssembly Engine for Research - https://github.com/titzer/wizard-engine
In A fast in-place interpreter for WebAssemblyA classic "easy" thing that appears "hard": write a little bit of assembly. Note, a little bit[1].
Writing assembly, again, in small amounts, is exactly the kind of thing that is difficult to start, and fails spectacularly if you have little experience. Debugging is a pain. But you can totally get the hang of writing assembly, and as long as you are doing it for the right reasons (TM), it's justified, and heroic. The key is you need to write and debug a little at a time.
Case in point, I wrote an entire Wasm interpreter[2] in x86-64 asm over the past few months. I wrote it a little at a time, had lots of unit tests, and am working in an engine that was already completely functional (with a slower interpreter).
[1] If you find yourself writing more than a hundred or so assembly instructions in a sitting, you are going to fail. If you find
Read the rest
yourself writing more than a few thousand assembly instructions, total, you have probably have already failed.
[2] https://github.com/titzer/wizard-engine/blob/master/src/engi...