Heavy Wizardry 101

General Thoughts

Heavy Wizardry 101 earns its hardcover. David Martínez Oliveira (Pico) takes you from foundational computer architecture through C and assembly exploit development, ending with a fully functional assembly worm that propagates across x86_64, ARM, MIPS, and RISC-V. The wizard theming runs deeper than decoration. Chapter titles like "Spell of the Binary Oracle" and "Veil of Ash" match the actual progression from apprentice to practitioner, and by the final chapters I genuinely felt like one.

This is the only No Starch Press book on my shelf with a hardcover, and the production quality matches the content. The technical depth and usefulness of what Pico covers made me feel like it earned that printing. 464 pages of C and assembly exploit development across four architectures is a lot of material, and the physical book holds up as a reference I'll keep reaching for.

I came into this with solid x86 assembly experience and limited exposure to the other architectures. The book's approach of implementing every concept across all four forced a kind of understanding I didn't expect. Instead of memorizing opcodes and register names per Instruction Set Architecture (ISA), I started recognizing the principles that carry across all of them. That shift from architecture-specific memorization to first-principles fluency is the most valuable thing I took from this book.

The trade-off is density. Pico does not hold your hand. He expects you to parse assembly, understand basic systems concepts, and keep pace with substantial blocks of code. There were stretches where I was reading more code than I fully absorbed in a single pass. The sheer volume of assembly across four architectures is tough to get through at times, but working that close to the hardware, across that many ISAs, is exactly what makes you feel like a wizard by the end. The title is fitting.

Chapter Breakdown

Part I: Into the Machine: Awakening Code Spells

Chapter 1: Spell of the Binary OracleWhen Hardware Whispers in Opcodes

Pico builds a computer model from scratch: memory abstractions, a minimal CPU, and your first programs written in raw hex opcodes before graduating to an assembler. Then the same program gets assembled for every ISA the book covers. The foundational material was familiar territory for me as an x86 practitioner, but seeing those same concepts expressed in other instruction sets for the first time reframed how I thought about processor architecture in general.

Chapter 2: Spell of EssenceDistilling C to Its Primordial ASM

My favorite chapter in the entire book. It walks through how _start differs from main, static versus dynamic binaries, stripping libc, avoiding executable stacks, and binary size optimization. Then it maps out system call conventions across all six architecture variants. This chapter gave me a much deeper understanding of how software is abstracted at each level. Seeing exactly how code gets added during compilation and linking, then learning to strip it all away for minimal binaries, was the content I didn't know I needed.

Chapter 3: Spell of RebirthTransmuting Greetings into Shellcode

Covers data representation, memory models, endianness, pointers in both ASM and C, and introduces the GNU Debugger. Then it transmutes a "Hello World" into position-independent shellcode. Mostly review for me, but it served as a clean demonstration of how C transitions into assembly, and the shellcode conversion process across different ISAs reinforced concepts I'd only seen from the x86 side.

Chapter 4: Spell of the Overflowing FrameMastering Stack Secrets

The real shift. Pico digs into stack internals, function calling conventions, prologues and epilogues, local variables, then builds a vulnerable program, triggers a buffer overflow, and writes a working exploit. Stack exploitation is something I know fairly well on x86, but seeing how each architecture handles it differently, including their respective canary implementations, was when I stopped memorizing and started understanding. The cross-architecture treatment of calling conventions alone was worth the chapter.

Chapter 5: Spell of the UndeadWriting a REPL to Animate a Botnet

Builds a REPL (Read-Eval-Print Loop) first in C covering arrays, loops, and conditionals, then implements it in assembly with jump instructions, processor flags, and buffer initialization. It formalized a lot of intuition I had about how programs actually work at the lowest level. The chapter culminates in a minimal botnet with a C2 REPL and zombie REPL, which was a satisfying payoff for the foundational work.

Part II: Onto the Network: Unveiling Mystic Gateways

Chapter 6: Veil of ShadowsUnlocking Hidden Backdoors

Opens with a networking primer on sockets, TCP/UDP, and the network layers, then builds a reverse shell backdoor in C: socket creation, file descriptor manipulation, launching a shell, and covering tracks. Then it converts the whole thing to assembly, optimizes for size, and adapts it across ISAs. The networking primer felt like an odd fit for a book at this level. Most readers comfortable writing assembly already know socket fundamentals. Reasonable safety net, but I skimmed it.

Chapter 7: Veil of AshThe Dropper That Leaves No Flame Behind

Dropper construction from scratch in C with a build system. The anti-forensics section walks through writing to RAM disk, memfd_create for anonymous file descriptors, and fexecve for executing payloads entirely from memory. No disk trace. This chapter had the strongest real-world applicability in the book. The in-memory execution techniques are things I've encountered in professional work, and seeing them built from C down to assembly deepened my fluency at exactly the boundary where it matters most.

Part III: Through the Network: Casting Crawlers

Chapter 8: Casting the Twin SerpentSummoning a Two-Headed Worm

The big build chapter. Pico implements a remote shellcode executor, sets up a simulated target network with Docker and QEMU, codes a file transfer server, then designs and deploys a two-stage worm with a downloader stage and a payload stage. It also covers how worms go wrong: packet storms, race conditions, and troubleshooting. This is where everything came together. The setup instructions for the simulated network were detailed and worked smoothly, which is worth calling out. Technical books often hand-wave the lab environment. Pico didn't.

Chapter 9: Casting the Lone StrandSingle-Stage Wormcraft

Refactors the two-stage worm into a single self-contained binary, then implements it independently for each architecture. Each section covers the payload, the vulnerable machine setup, and the main propagation loop. This was the hardest slog. A wall of assembly, and by this point I was getting the high-level ideas but also forcing myself through sections where I was reading more code than I truly absorbed. The repetition that built fluency in earlier chapters hit diminishing returns here.

Chapter 10: Casting the Lost HostsConjuring Network Scanners

The book closes well. Pico builds a port scanner in C covering IP and netmask discovery, scan scope calculation, and non-blocking I/O for speed, then converts it to assembly and integrates it into the worm. The scanner is the final missing piece: with it, the worm can find its own targets instead of relying on a hardcoded IP list. Walking out of the final chapter with a complete, self-propagating worm in 545 bytes of x86_64 left me looking back at 400+ pages of material I'd internalized more deeply than I expected.

The Forge (Appendixes)

Appendix A: The Sorcerer's ForgePreparing Your Workshop

Covers development environment setup and cross-compilation toolchains for all target architectures.

Appendix B: Secrets of the ForgeArcane Tricks for Low-Level Tools

The standout appendix. GNU Assembler tricks (Intel syntax, lea, delay slots), GDB configuration and debugging with QEMU, gcc flags, objdump/objcopy for manipulating ELF sections and symbols, binfmt_misc for transparent cross-architecture execution, handcrafting minimal ELF binaries, symbol resolution and relocation, and quick reference tables. This appendix alone turns the book into a long-term reference I expect to revisit regularly.

Appendix C: The Sorcerer's AnvilFull Spellcraft Listings

Complete worm source code for all target architectures in one place. Made cross-referencing easy while working through the main chapters and was a welcome inclusion.

Who Should Read This

This book is for anyone looking to push past scripting languages into C and assembly exploit development. If you can write a basic C program and have seen assembly before, even just x86, you have enough foundation. Security practitioners who want to understand offensive tooling at the lowest level will get the most from it. Developers curious about what happens below their abstractions will find the compilation and linking material alone worth the read. Skip it if you want a gentle tutorial or aren't prepared to parse dense assembly across multiple architectures.

Closing

The lasting impression is how similar the different assembly languages actually are. Different opcodes, different registers, architecture-specific quirks to code around, but they are doing many of the same things the same way. I came in knowing x86 and left feeling fluent in the principles that carry across all of them. That kind of cross-architecture understanding is rare to find in a single book.

The format deserves credit too. Pico's approach of building every concept first in C, then pulling back the curtain into assembly, then repeating across architectures, creates a progression that compounds. By the time the worm chapters arrive, you have enough fluency across ISAs that the assembly stops feeling foreign and starts feeling like variations on a theme. The tips, tricks, and low-level techniques I picked up throughout are things I'm excited to apply in my own work, from the binary size optimization in Chapter 2 to the ELF handcrafting in Appendix B.

The book also works on two timescales. As a single read-through, it builds genuine fluency from foundations to a working worm. As a long-term reference, the appendixes, the detailed setup instructions, and the complete source listings make it something I'll keep pulling off the shelf. Most technical books give you one or the other.

9/10. The only thing keeping it from a perfect score is that the density of cross-architecture assembly might be too intimidating for someone brand new to the subject. Everything else earned its place.

Where to Buy

Heavy Wizardry 101 was published by No Starch Press in 2026 and runs 464 pages in hardcover.