binaryen VS abrash-black-book

The Binaryen wasm optimizer (mentioned in the article) is always open for contributions,

https://github.com/WebAssembly/binaryen

The end of the related work section cites both wasm-smith and the Binaryen fuzzer (https://github.com/WebAssembly/binaryen/wiki/Fuzzing) and says, "They both provide a fuzzer that turns a stream of bytes into a WebAssembly module in order to test implementations. Their fuzzers always generate semantically valid test cases, but lack the targeting and tuning that Xsmith provides."

I look forward to reading more about how they do the targeting and tuning.

Binaryen or the LLVM of wasm: https://github.com/WebAssembly/binaryen

Download Binaryen

Probably https://github.com/WebAssembly/binaryen/, there were various rust bindings to it.

The final phase of our compiler is code generation. This phase takes the AST and converts it to a set of executable instructions. In our case, WebAssembly. To accomplish this, we are going to use a popular WebAssembly compiler toolchain called binaryen.

In this guide, we will be using TypeScript and NodeJS. The concepts are highly portable, so feel free to use the environment you're most comfortable with. Our only major dependency, binaryen, has a simple C API. You are welcome to skip ahead to the next section if you're using a different language.

What are the size and performance benefits of processing the Wasm payload with wasm-opt?

I would recommend looking into binaryen as it has it's own IR and can perform optimizations over it. It's also simpler than LLVM and has the option to produce binaries with debug names.

You can also use binaryen to optimize your wasm output

Michael Abrash's Graphic Programming Black Book

[Michael Abrash's Black Graphics Programming Black Book from 1997 is a fantastic book I wish I had back then. It is available for free on GitHub. I read it maybe in 2015 and I thought it was fantastic even if it is dated now. It goes through the evolution of PC hardware (CPU and graphics cards in particular) from the very first IBM PC to the mid-90's pentiums, and the last chapter or two are about the author's work on Quake.

Also available in eReader formats: https://github.com/jagregory/abrash-black-book/releases

Also look at the source for original Quake (https://github.com/id-Software/Quake), one of the last pure software-rasterizing AAA 3D PC games. Michael Abrash's Graphics Programming Black Book (https://github.com/jagregory/abrash-black-book) explains many of the critical parts of the rendering pipeline.

By the way, quake.exe for DOS was 404,480 bytes.

It's also THICK. I have my copy of the 5th edition right here, and it's about 3 inches from cover to cover. Thicker than Introduction to Algorithms and thicker than the Graphics Programming Black Book.

Read Michael Abrash's Graphics Programming Black Book for the story of how the original Quake came to life. You'll get an appreciation for John Carmack's ability to thoroughly research widely varying solutions to a problem, quickly create production-quality implementations of the promising ones, and even more quickly abandon the dead ends. The result is this almost boring, seemingly linear progression toward a final product that seems obvious in hindsight, yet it represents a leap forward the way Quake did in the mid-1990s compared to other FPSes at the time. I don't know many other public stories of individual engineers who can span both the very cutting edge of research and the practicalities of shipping real commercial software.

https://github.com/jagregory/abrash-black-book

The Abrash black book is on github!

Go through Michael Abrash's Graphics Programming Black Book to see how it used to be on PC world.