Christine Lemmer-Webber17h ago

New blogpost from @wingo about Wastrel: "Wastrelly Wabbits" https://wingolog.org/archives/2026/03/31/wastrelly-wabbits

So you very likely haven't heard about Wastrel BUT YOU SHOULD because it's pretty cool! Wastrel takes WASM binaries and compiles them directly to C!

And here you'd think that was WASM 1 type binaries, the linear memory style things Rust and emscripten etc can spit out.

BUT NOT ONLY THAT, it can also compile things with WASM-GC! Because it can use @wingo's Whippet garbage collector and pull that in

WHICH MEANS since you can compile Hoot programs to WASM-GC we finally are approaching a path where you can compile a Guile Scheme program directly to a native binary, no intermediate Guile VM!

Wild right?

wastrelly wabbits — wingolog

wingolog: article: wastrelly wabbits

Show threadChristine Lemmer-Webber

BUT WAIT THERE'S MORE! Wastrel actually *uses* Hoot's WASM tooling to do this stuff. And... hm, now this is interesting.

A lot of people know that @spritely's Hoot can compile Scheme -> Webassembly, but what less people know is that Hoot is a *whole WASM toolkit*. We don't use emscripten, etc. Hoot brings its own assembler, disassembler, and even *interpreter*... you can actually *run* WASM programs in it (albeit slowly) and even insert WASM instructions line-by-line at the REPL... a feature, that as far as I know, is *exclusive* to Hoot.

Which also means, you can write *low-level* WASM programs with Hoot, and then test and debug them.

Okay, very interesting! Is this going somewhere? It is...

Apr 1 at 2:59pmWeb
Show threadChristine Lemmer-Webber17h ago

And you can see an example of "low-level" Webassembly programs being written with the Wireworld demo we did back in the day (largely @terpri's work) https://spritely.institute/news/hoot-wireworld-live-in-browser.html

So now maybe you're thinking: that's cool and all, but that low-level WASM tooling looks kinda painful. But in the blogpost we show some rudimentary high-level abstractions, and how since this is a lisp and WASM has an s-expression syntax, it's actually kind of trivial to build up higher level abstractions.

And Guile has a compiler tower, so it would actually be possible to build higher-level languages which compile to WASM directly, and even kind of build that up experimentally / gradually

Lisp Game Jam - "Wireworld" - Hoot's low level Wasm tooling in action — Spritely Institute

Show threadChristine Lemmer-Webber16h ago

Which is all to say, what if you wanted to develop a new "low-level" language in the realm of C and Rust?

Well, why not start with WASM as a default backend? And why not use Hoot? You could compile classic linear-memory style programs to WASM and execute them and even play with them in Hoot's interpreter. It could be a lovely environment to do experiments with low-level programming languages.

I have thought this for a while and thought, "and you could add native backends later".

BUT

Now that Wastrel exists, you can even accelerate straight to that step: you can compile your new language to Webassembly, then compile it to C, then compile it to a native binary!

I think this would be *really fun* to play with!

Show threadChristine Lemmer-Webber16h ago
Anyway, by now maybe I have convinced you Hoot is cool, AND IT IS, and you should play with it... both for the low level and high level stuff! https://spritely.institute/hoot/
Hoot: Scheme on WebAssembly — Spritely Institute