Best Assembly Language Books for 2026: x86-64, ARM64 and RISC-V

For most people the best assembly language book is x64 Assembly Language Step-by-Step, because it teaches x86-64 on Linux with free tools. If your code will run on a phone, a Mac or a Raspberry Pi, start with an ARM64 title instead, and if you work on chips or embedded boards, pick a RISC-V one.

Original content from computingforgeeks.com - post 179679

This list covers eleven books across x86-64, ARM64 and RISC-V, matched to reverse engineering, OS development and performance work. We checked the assembler each book expects in October 2026 on Ubuntu 26.04, building one program natively for x86-64 and under QEMU for ARM64 and RISC-V.

Which assembly book should you buy first?

Buy the book that matches the CPU you’ll actually run code on, because x86-64, ARM64 and RISC-V share ideas but almost no syntax. A beginner who learns registers and calling conventions on one architecture picks up the second one in a fraction of the time, so the first book matters far more than the second. These are the picks for each goal, and the reasoning for every one follows further down.

• Best first book (x86-64, Linux): x64 Assembly Language Step-by-Step, 4th Edition. It explains how the CPU sees memory before any code, then teaches NASM on Linux.
• Best for performance and SIMD: Modern X86 Assembly Language Programming, 3rd Edition. AVX, AVX2 and AVX-512 called from C++, on Windows and Linux.
• Best x86-64 reference on Windows: The Art of 64-Bit Assembly, Volume 1. Over a thousand pages of MASM with Visual Studio.
• Best for ARM64: The Art of ARM Assembly, Volume 1. Gas syntax on Linux and the Raspberry Pi, Clang on macOS.
• Best for reverse engineering: Blue Fox. ARM internals read the way an analyst reads them, from ELF headers to firmware.
• Best for RISC-V: RISC-V Assembly Language Programming. Hands-on code with QEMU and a VisionFive 2 board.
• Best for OS development: Low-Level Programming. It follows a program from NASM source through the linker and loader into a running process.

If you’re still unsure, let your target decide it. A Windows reverse engineer reads x86-64 all day, a mobile security researcher reads ARM64, and someone writing a kernel for a hobby board will likely meet RISC-V first, so the book that matches that work is the one you will finish.

How did we pick and test these books?

We started from what readers search for (x86-64, ARM, RISC-V, beginners, reverse engineering) and from each publisher catalog, then kept only books that are in print and buyable as a paperback or hardcover today. Every edition, page count and publication date comes from the publisher page or Amazon catalog data pulled in October 2026, and every cover matches the edition we link. Assembly sits one layer under C, so this list pairs with our C and C++ books, and the wider shelf lives in our best programming books guide.

Assembly books age by toolchain more than by topic, so we checked which assembler and operating system each one uses and then built a test program with those tools on an Ubuntu 26.04 VM. That check matters because a book written for MASM on Windows is a poor fit if you live in a Linux terminal, and you only find that out after the first example fails to assemble. Each book had to pass three checks:

• The edition we link is the newest one in print, and the cover in this guide shows that same edition.
• The assembler named in the book (NASM, GNU as or MASM) is free to install on the platform the book targets.
• The book still matches a current 64-bit CPU, or we say plainly where it does not.

We left out the long-running Assembly Language for x86 Processors by Kip Irvine because the only new copy listed in October 2026 was a loose-leaf print offer at close to a thousand dollars. Self-published RISC-V titles were also skipped, since there is no publisher review behind them and we could not check their accuracy ourselves.

How do the assembly books compare?

The table shows the instruction set, the assembler and the host OS for each pick, which is the fastest way to rule books in or out.

Book	ISA	Assembler	Host OS	Published	Best for
x64 Assembly Language Step-by-Step, 4th Ed.	x86-64	NASM (SASM IDE)	Linux	2023	First book
Modern X86 Assembly Language Programming, 3rd Ed.	x86-64 + AVX-512	MASM and NASM	Windows, Linux	2023	Performance
The Art of 64-Bit Assembly, Vol. 1	x86-64	MASM	Windows	2021	Depth on Windows
The Art of 64-Bit Assembly, Vol. 2	x86-64	MASM	Windows	2026	Advanced MASM
Low-Level Programming	x86-64	NASM	Linux	2017	OS development
The Art of ARM Assembly, Vol. 1	AArch64 + Neon	Gas or Clang	Linux, macOS, Pi	2025	ARM64 depth
Programming with 64-Bit ARM Assembly Language	AArch64	GNU as	Raspberry Pi, Linux	2020	ARM64 on a budget
Blue Fox	A32, T32, A64	Disassemblers	Linux, macOS	2023	ARM reverse engineering
Practical Reverse Engineering	x86, x64, ARM	Disassemblers	Windows	2014	Windows reversing
RISC-V Assembly Language Programming	RV64 + RV32 (ESP32-C3)	GNU as	Linux, QEMU	2024	RISC-V hands-on
Computer Organization and Design, RISC-V Ed.	RV32/RV64	Textbook	Any	2020	How CPUs work

Two patterns jump out of that table. The x86-64 shelf splits cleanly between Windows books that use MASM and Linux books that use NASM, so your operating system narrows the choice before the topic does. The ARM and RISC-V programming books use the GNU assembler syntax, which means a Linux machine with cross binutils covers their exercises. The two Hyde x86 volumes and the Windows kernel chapters of Practical Reverse Engineering are the exceptions. If you run Windows and want to follow the Linux books anyway, WSL is the cheapest way to get that toolchain.

1. x64 Assembly Language Step-by-Step, 4th Edition

Jeff Duntemann wrote the gentlest real introduction to x86-64 we found, and the fourth edition moves the series from 32-bit protected mode to 64-bit long mode on Linux. That rewrite matters because older editions taught a register set and calling convention you won’t see in a modern binary. The book also spends real time on how the CPU and memory work before the first program, so beginners arrive at the code with a model to hang it on.

Who it suits: programmers who know a high-level language and want to see what the CPU does with it. The author uses the free NASM assembler with the SASM IDE, so the whole toolchain comes from your distro packages and you can start the same day. Look elsewhere if you want SIMD, AVX or optimisation work, since that is the Kusswurm book’s territory, and the patient pace will feel slow if you already read disassembly at work.

• The fourth edition (Wiley, October 2023) runs to 640 pages in hardcover.
• Code listings are on contrapositivediary.com, under “My Assembly Language Books”.
• Every example targets 64-bit Linux and calls into the C library where it needs to.
• The new price sits between about $40 and $70 depending on the seller, so check the current price on Amazon.

2. Modern X86 Assembly Language Programming, 3rd Edition

Daniel Kusswurm writes for people who already code in C++ and want specific functions to go faster. Each example pairs a C++ driver with an assembly routine, so you always see the slow version and the fast one side by side. The third edition covers AVX, AVX2 and AVX-512, which is where hand-written assembly still beats the compiler often enough to be worth learning.

Best fit: performance engineers, game and codec developers, and anyone tuning a hot loop. We went through the companion repository on GitHub, and nearly every example ships twice: a MASM file with a Visual Studio project for Windows and a NASM file with a makefile for Linux. Look elsewhere if this is your first contact with assembly. The book assumes you know C++ and the basic x86 registers, and every example is driven from C++ code.

• The third edition (Apress, 2023) has about 700 pages.
• The code lives at github.com/Apress/modern-x86-assembly-language-programming-3e, with build scripts for both Windows and Linux.
• The AVX-512 examples need a processor that supports AVX-512, so check your CPU before you buy the book for those chapters.
• New copies usually sell for about $50 to $70, so check the current price on Amazon.

3. The Art of 64-Bit Assembly, Volume 1

Randall Hyde wrote the most thorough single volume on x86-64 programming in print, at over a thousand pages, and it covers integer code, the x87 FPU, SSE and AVX, and the MASM macro language. It’s also firmly a Windows book, so the first question is whether you work on Windows. If you do, nothing else on this list goes as deep, and if you do not, the length works against you.

Buy it for: Windows developers and Windows malware analysts who want to write MASM themselves, linked with C and C++ through Visual Studio, and the appendices walk through installing Visual Studio. Look elsewhere if you work on Linux. MASM syntax and the Windows calling convention differ from what NASM and GNU as expect, so translating every example costs more time than buying a Linux book in the first place.

• This first edition (No Starch Press, 2021) has 1,032 pages.
• Stock was thin in October 2026, with the buy box held by a third-party seller, so compare sellers before you order.
• Prices ran from about $60 up to the $80 list price.

4. The Art of 64-Bit Assembly, Volume 2

Volume 2 came out in August 2026 and picks up where the first book stops, with object-oriented code at the machine level, Windows structured exception handling, concurrency, coroutines and fibers. Those are the constructs that make real Windows binaries hard to read, because a compiler turns them into tables and indirect calls instead of tidy functions. It’s the newest book on this list, and Amazon had it in stock in October 2026.

Ideal reader: someone who finished Volume 1, or a reverse engineer who keeps meeting vtables and SEH frames in Windows binaries. Seeing how those structures can be built by hand in MASM makes them much easier to recognise in a disassembler. Look elsewhere if you haven’t read Volume 1 or something like it. The publisher pitches it at readers who already know assembly, and it stays on MASM under Windows throughout.

• The book has 792 pages and was published by No Starch Press in August 2026.
• Amazon sold it directly in October 2026 for about $60, against an $80 list price.
• Its chapters cover advanced macros, Unicode, concurrency, exceptions, thunks, iterators and coroutines.

5. Low-Level Programming

Igor Zhirkov wrote the book to read if your goal is an operating system, a compiler or a language runtime. It follows a program from NASM source through the assembler, linker and loader into a process, then shows how C maps onto all of it. You finish with a working model of what happens before main() runs, which is exactly the knowledge a bootloader or kernel project assumes.

Best fit: OS hobbyists, systems students and anyone moving on to our operating systems books or Linux kernel programming books. The listings and assignments sit in the Apress GitHub repository, and its FAQ points Windows users to WSL. Look elsewhere if price matters. The 2017 first edition is the only one, and in October 2026 new copies came from third-party sellers at close to the $100 list price, so a used copy is the sensible way in.

• The book runs to 461 pages (Apress, 2017).
• All examples use NASM syntax for x86-64 on Linux.
• New copies were selling for roughly $90 to $100, which is why we suggest checking used listings first.

6. The Art of ARM Assembly, Volume 1

This Randall Hyde volume does for 64-bit ARM what his x86 book does for Intel, but with the GNU assembler instead of MASM. That one change makes it far more useful to Linux and macOS users, because GNU as is already installed wherever binutils is. It covers AArch64 from data representation up to Neon SIMD, with makefiles and Bash scripts rather than an IDE.

Buy it for: developers on Apple Silicon Macs, Raspberry Pi owners and anyone who wants the most complete ARM64 text we could find. You can follow it on an x86 Linux box too, because cross binutils and QEMU ran the same style of AArch64 code in our test below. Look elsewhere if you want 32-bit ARM or Cortex-M microcontrollers, since this volume is about 64-bit application processors. The author site announces a Volume 2 for 32-bit Pi OS and Cortex-M, due in late 2026.

• The book has 1,064 pages and was published by No Starch Press in 2025.
• Its examples use GNU as syntax, the same assembler you get in binutils on any Linux distribution.
• Amazon sold it directly in October 2026 for about $55, well under the $90 list price.

7. Programming with 64-Bit ARM Assembly Language

Stephen Smith wrote an ARM64 book that is less than half the length of the Hyde volume and usually less than half the price, built around single-board computers like the Raspberry Pi. That focus is the reason to buy it, because you get a program running on real hardware the same evening instead of reading three hundred pages first. It is the pick for people who learn by doing.

Ideal reader: a hobbyist with a Pi on the desk, or a developer who wants a short path into AArch64 on Linux with GNU as and ld. The subtitle names the Raspberry Pi and mobile devices, so the examples stay close to hardware you can buy cheaply. Look elsewhere if you need depth on Neon or system-level ARM, since it’s shorter on those topics than the 2025 Hyde book. Smith also published Raspberry Pi Assembly Language Programming, Second Edition, in November 2025, which Apress describes as moving to 64-bit for current Pi OS, so compare the two before you order.

• The book has 453 pages (Apress, 2020).
• Chapter code is in the Apress GitHub repository for the title.
• It is one of the cheapest picks here, at about $26 to $55 depending on discounts.

8. Blue Fox: Arm Assembly Internals and Reverse Engineering

Maria Markstedter teaches ARM assembly from the reading side of the disassembler rather than the writing side. The book covers both AArch32 (A32 and T32) and AArch64, then ELF internals, static and dynamic analysis, firmware extraction and emulation, and a chapter on macOS malware on M1 machines. That order matches how an analyst actually meets ARM code, so you learn each instruction in the context where you will see it.

Best fit: mobile and IoT security researchers, and anyone heading for exploit work after our OSCP books. Pair it with Ghidra, which we set up in our Ghidra install guide, and you have a complete ARM reversing kit. Look elsewhere if you want to write ARM programs. Blue Fox explains instructions so you can read compiled code, and the Hyde or Smith books fit that goal better.

• The book has 480 pages (Wiley, April 2023).
• It covers 32-bit and 64-bit ARM, which matters because plenty of firmware still runs Thumb code.
• Amazon listed it at about $28 in October 2026, against a $45 list price from Wiley.

9. Practical Reverse Engineering

Bruce Dang, Alexandre Gazet and Elias Bachaalany wrote this in 2014, and it is still the standard text for reversing Windows binaries and kernel code. It teaches x86, x64 and ARM side by side, then spends most of its length on the Windows kernel, reversing tools and obfuscation. The age shows in places, but the method of reading compiler output has not changed, which is why it stays on the list.

Buy it for: Windows malware analysts and driver researchers who need to read compiler output fast, and it sits naturally next to the reversing titles in our cybersecurity books list. Look elsewhere if you need current ARM64 coverage. Its ARM chapter is 32-bit and the Windows internals reflect kernels from around 2014, so treat the kernel material as a method rather than a map of current structures.

• The book has 384 pages (Wiley, 2014), and there is no second edition.
• Its subtitle lists the coverage: x86, x64, ARM, the Windows kernel, reversing tools and obfuscation.
• It sold for about $28 in October 2026, around half of the $58 list price.

10. RISC-V Assembly Language Programming

Stephen Smith also wrote the most practical RISC-V assembly title from a major publisher, and it uses the same GNU tools as his ARM book. The companion repository includes makefiles, GDB setup files, a QEMU setup, files for the StarFive VisionFive 2 board and an ESP32-C3 microcontroller project. That combination means you can work through the whole book on a laptop and only buy a board if you want to run on real silicon.

Who it suits: embedded developers, students and anyone curious about the open ISA. RISC-V has a small, regular instruction set, so it also makes a good second architecture after x86-64 because the contrast teaches you what x86 complexity buys. Look elsewhere if you want microarchitecture or CPU design, since this is a programming book and the textbook in the next pick covers the hardware side.

• The paperback has 379 pages (Apress Maker Innovations series, February 2024).
• Its ISBN starts with 979, which is why the Amazon listing has a B0 code instead of an ISBN-10.
• Amazon sold it directly for about $40 in October 2026, against a $55 list price.

11. Computer Organization and Design RISC-V Edition, 2nd Edition

David Patterson and John Hennessy teach how a processor executes instructions, using RISC-V as the running example. Chapter 2 is a full tour of the RISC-V instruction set, and the rest builds a datapath, a pipeline and a memory hierarchy. That second half is what performance engineers need, because it explains why two instruction sequences with the same result can run at very different speeds.

Ideal reader: students and performance engineers who want to know why caches, pipelines and branch prediction shape fast code. It reads as a course text, built chapter by chapter from instructions to processor to memory hierarchy. Look elsewhere if you want to write programs this week, because it has no toolchain walkthrough and the price is textbook-high.

• The second edition (Morgan Kaufmann, December 2020) has 736 pages and replaces the 2017 first edition.
• New copies came from a third-party seller at close to $100 in October 2026, so compare used and international editions.
• Pair it with pick 10 if you want both the hardware view and hands-on code. For the wider hardware shelf, from Petzold’s Code to Hennessy and Patterson’s quantitative text, see our guide to computer architecture books.

What do you need installed to follow these books?

On Linux you need NASM, binutils and GDB for the x86-64 books, plus the cross binutils and qemu-user for the ARM64 and RISC-V ones. We installed all of that on a fresh Ubuntu 26.04 VM and built a tiny write-and-exit program for each architecture, so you can see the toolchain work before you buy a book that depends on it. The install pulled everything from the default Ubuntu archive and took about two minutes:

sudo apt-get update && sudo apt-get install -y nasm binutils gcc gdb make binutils-aarch64-linux-gnu gcc-aarch64-linux-gnu binutils-riscv64-linux-gnu gcc-riscv64-linux-gnu qemu-user

Confirm the versions you got before you start a book, since an assembler that is years older than the book can reject newer instructions:

nasm -v; as --version | head -1; aarch64-linux-gnu-as --version | head -1; qemu-riscv64 --version | head -1

Ubuntu 26.04 shipped these builds in October 2026:

NASM version 3.01
GNU assembler (GNU Binutils for Ubuntu) 2.46
GNU assembler (GNU Binutils for Ubuntu) 2.46
qemu-riscv64 version 10.2.1 (Debian 1:10.2.1+ds-1ubuntu3.3)

The native and cross builds of GNU as come from the same binutils release, so syntax that works in one works in the others for the shared directives.

How does x86-64 look in NASM?

The Duntemann and Zhirkov books, and the Linux half of the Kusswurm repository, all use NASM syntax, where the destination operand comes first. Create the source file:

vim hello-nasm.asm

Add this program, which calls the Linux write and exit system calls directly:

; x86-64 Linux, NASM (Intel syntax)
        section .data
msg:    db "hello from x86-64 (NASM)", 10
len:    equ $ - msg
        section .text
        global _start
_start:
        mov     eax, 1          ; sys_write
        mov     edi, 1          ; fd 1 = stdout
        lea     rsi, [rel msg]
        mov     edx, len
        syscall
        mov     eax, 60         ; sys_exit
        xor     edi, edi
        syscall

Assemble it into an ELF object, link it with ld and run it:

nasm -f elf64 hello-nasm.asm -o hello-nasm.o && ld hello-nasm.o -o hello-nasm && ./hello-nasm

The program prints its message and exits with status 0:

hello from x86-64 (NASM)

Our first mistake is the one every beginner makes. We fed a GNU as file written in AT&T syntax (movl $1, %eax) to NASM, and NASM rejected nearly every line:

hello-gas.s:1: error: `#' expects a line number
hello-gas.s:3: error: instruction expected, found `.ascii'
hello-gas.s:8: error: instruction expected, found `movl $1'
hello-gas.s:10: error: instruction expected, found `leaq msg'

NASM and GNU as use different syntax for the same instructions, so code from a GNU as book won’t assemble in NASM, and the reverse fails too. The errors do not say “wrong syntax”, which is why beginners lose an evening to them. Check the assembler column in the comparison table before you copy examples between books, and assemble AT&T files with as, which built the same file without complaint in our test.

Can you run ARM64 code on an x86 PC?

Yes. The cross assembler builds an AArch64 binary, and the QEMU user-mode emulator runs it on your x86 machine, which is enough for every ARM exercise that doesn’t touch hardware. Create the file:

vim hello-arm64.s

The same program in AArch64 syntax puts the system call number in x8 and traps with svc:

// AArch64 Linux, GNU as
        .data
msg:    .ascii "hello from ARM64\n"
        len = . - msg
        .text
        .globl _start
_start:
        mov     x0, #1          // stdout
        adr     x1, msg
        mov     x2, #len
        mov     x8, #64         // write
        svc     #0
        mov     x0, #0
        mov     x8, #93         // exit
        svc     #0

Build it with the aarch64-linux-gnu tools and run it under QEMU:

aarch64-linux-gnu-as hello-arm64.s -o hello-arm64.o && aarch64-linux-gnu-ld hello-arm64.o -o hello-arm64 && qemu-aarch64 ./hello-arm64

The emulated program prints its line just like the native one:

hello from ARM64

One surprise: running ./hello-arm64 without the qemu-aarch64 prefix also worked. With default apt settings, Ubuntu installs the recommended qemu-user-binfmt alongside qemu-user, and that package registers QEMU with the kernel for foreign ELF binaries. The practical result is that static ARM64 and RISC-V test programs run as if they were native. GPIO chapters still need the real board, and examples linked against glibc may need -static or qemu-aarch64 -L /usr/aarch64-linux-gnu.

What does the RISC-V version look like?

RISC-V uses the same Linux system call numbers as ARM64 (64 for write, 93 for exit), but the registers have ABI names like a0 and a7. Open a new file:

vim hello-rv64.s

Paste the RISC-V program:

# RISC-V 64 Linux, GNU as
        .data
msg:    .ascii "hello from RISC-V\n"
        len = . - msg
        .text
        .globl _start
_start:
        li      a0, 1           # stdout
        la      a1, msg
        li      a2, len
        li      a7, 64          # write
        ecall
        li      a0, 0
        li      a7, 93          # exit
        ecall

Assemble, link and run it with the riscv64 tools:

riscv64-linux-gnu-as hello-rv64.s -o hello-rv64.o && riscv64-linux-gnu-ld hello-rv64.o -o hello-rv64 && qemu-riscv64 ./hello-rv64

QEMU prints the expected line:

hello from RISC-V

The disassembly shows something the RISC-V books spend time on, so dump it:

riscv64-linux-gnu-objdump -d hello-rv64

Every instruction is 4 bytes, and our one-line la a1, msg became two real instructions:

00000000000100e8 <_start>:
   100e8:	00100513          	li	a0,1
   100ec:	00001597          	auipc	a1,0x1
   100f0:	02058593          	addi	a1,a1,32 # 1110c <__DATA_BEGIN__>
   100f4:	01200613          	li	a2,18
   100f8:	04000893          	li	a7,64
   100fc:	00000073          	ecall
   10100:	00000513          	li	a0,0
   10104:	05d00893          	li	a7,93
   10108:	00000073          	ecall

RISC-V builds a PC-relative address from auipc plus addi, because a single 32-bit instruction has no room for a full address. Compare that with the x86-64 build, where objdump showed instructions from 2 to 7 bytes long. This build used only 4-byte encodings, though RV64GC binaries from a distro also mix in 2-byte compressed instructions. Mostly fixed-width encoding is why RISC-V and ARM64 disassembly reads so evenly, and variable-width x86 is why reverse engineering books spend whole chapters on decoding.

How do you read compiler output for performance work?

Most performance work starts by reading what the compiler produced, not by writing assembly from scratch. We compiled a three-argument add function with -O2 for all three architectures, starting from this one-line C file:

echo 'long add3(long a, long b, long c) { return a + b + c; }' > add.c

Ask GCC for Intel-syntax assembly instead of an object file:

gcc -O2 -S -masm=intel -fno-asynchronous-unwind-tables -o - add.c

The function body is three instructions after the CET marker (assembler directives trimmed):

add3:
	endbr64
	add	rdi, rsi
	lea	rax, [rdi+rdx]
	ret

GCC used lea to add two registers and store the result in rax in one instruction, an address-arithmetic trick you will see constantly in optimised x86 code. The endbr64 line is a control-flow protection marker that Ubuntu’s GCC adds by default, and it confuses readers whose book predates it. The AArch64 and RISC-V builds produced plain add x0, x0, x1 and add a0, a0, a1 pairs followed by ret, because both ISAs pass the first arguments in registers and return the result in the first one.

If you work on Fedora instead, the same packages exist under different names, and our guide to installing GCC and development tools on Fedora covers the base toolchain. The NASM manual at nasm.us is the reference to keep open next to any NASM-based book.

Which order should you read them in?

Read one programming book for your main architecture first, then one book for your goal. Two books in the right order beat five read at random, because the second one assumes you already think in registers and stack frames. These are the paths we would follow:

1. Reverse engineering on Windows: Step-by-Step for the basics, then Practical Reverse Engineering, adding Art of 64-Bit Assembly Volume 2 when C++ binaries start to show up.
2. Reverse engineering on mobile or IoT: the Smith ARM64 book or The Art of ARM Assembly, then Blue Fox.
3. OS development: Step-by-Step, then Low-Level Programming, then an operating systems text.
4. Performance work: Modern X86 Assembly Language Programming for SIMD, with Patterson and Hennessy for how caches and pipelines change the numbers.
5. RISC-V and embedded: RISC-V Assembly Language Programming on QEMU first, then the Patterson and Hennessy RISC-V edition.

Whichever path you choose, install the toolchain from the section above before chapter one. A book you can type along with on day one is the book you will actually finish, and the programming books here run on the free tools we tested, except the two MASM volumes, which need Visual Studio on Windows.