0xAX/asm: a seven-part Linux x86_64 assembly course you can build and run

What 0xAX/asm actually is, and who it is written for

The repository is a set of blog posts, not a tool. The README describes it as containing posts that introduce the assembly programming language, and says that for this moment all content and examples cover only x86_64 processors and the GNU Linux operating system. That scope sentence is the most important one on the page: this is Linux, 64-bit, one architecture.

The intended reader is broad on purpose. The README says the posts are intended for everyone, whether or not you are an experienced programmer. In practice the useful reader is someone who already writes code in another language and wants to see what sits underneath: how a program hands control to the kernel, what the stack does during a call, how floating point values are laid out in memory. The seven linked posts run from an introduction through x86_64 concepts, the stack, data manipulation, macros, floating-point arithmetic, and assembly interaction with high-level languages.

What it is not: there is no package to install, no runtime, no API. If you arrived looking for a library called asm, this is the wrong repository. The topics list is assembly, linux and x86-64, and the primary language recorded for the repository is Shell, which reflects the build scripts rather than the subject matter.

How the course is laid out, from content/ to examples/

The repository splits prose from code. The top level holds content/, examples/, scripts/, plus the usual project files: CONTRIBUTING.md, CODE_OF_CONDUCT.md, SECURITY.md, CONTRIBUTORS.md, LICENSE, and a lychee.toml used by the link checker workflow. The README links each post directly, for example content/asm_1.md through content/asm_7.md, so you can read on GitHub without cloning anything.

The examples directory is organised by topic rather than by chapter number. The entries listed are casm, float, hello, stack, strings and sum. Each is a small standalone program, which means you can open one, read the .asm file, and run make in that directory without pulling in the rest of the course. The README states plainly that the code examples that accompany the chapters live in the examples directory.

Two GitHub Actions workflows back this up: one checks links, one builds the examples. That second workflow is the closest thing to a guarantee that the sample code still assembles. It is not a test suite with assertions; it is a build check, and it only covers what lives in examples/.

There is also a single PDF book assembled from the posts, linked from the README as introduction-to-assembly.pdf. The README notes that all posts are available as that single PDF, which is the practical format if you want to read offline.

Installing the toolchain and running your first example

There is nothing to install from this repository. What you install is the toolchain the README lists under Requirements: a 64-bit distribution of Linux, make, NASM and binutils. On a Debian or Ubuntu machine those last three come from the package manager, and NASM is the assembler the examples target.

sudo apt install make nasm binutils

After that, clone the repository and change into one of the example directories. The README names examples/hello as one of the example locations, and each example directory is built with make, which is why make appears in the requirements list.

git clone https://github.com/0xAX/asm.git
cd asm/examples/hello
make

The Makefile in that directory drives NASM and the linker. Because the repository does not document the exact target names in the README, run make with no arguments first and read the output rather than guessing a target. What you should see is an assembled and linked executable in the same directory; run it and you get the program's output on stdout. If NASM is missing, the failure appears immediately as a command-not-found error, which is the fastest way to confirm the toolchain is incomplete.

The examples are small on purpose. examples/sum, examples/strings, examples/stack, examples/float and examples/casm each isolate one idea, and examples/casm is the one to look at if you care about calling assembly from a C program, which is the subject of the seventh post.

The x86_64 and Linux-only boundary is a real limit

The README is explicit that all content and examples cover only x86_64 processors and the GNU Linux operating system, and that ARM64 learning materials are planned for the future. Planned is not present. If you are working on an Apple Silicon laptop, an ARM server, or a Windows target, the assembly you learn here will not assemble and the syscall interface will not match. The system call discussion in the posts is Linux-specific by design, so the calling convention and the way a program asks the kernel for work do not transfer to other kernels.

A second limitation is that this is a reading course with a build check, not a reference. The README does not document rollback, versioning of the posts, or a changelog for the prose; the releases listed are v1.0.0, v1.0.1 and v1.0.2, and the README does not explain what changed between them. If you need a specification you can cite, this is the wrong source.

A third is licensing. The README states that each Markdown file in the repository is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. NonCommercial and ShareAlike are the two clauses that matter for reuse: this is not a permissive code license, and the repository's LICENSE file is the document to read before you copy chapters into internal training material. Note also that the repository's license metadata is reported as NOASSERTION, which means automated tooling will not classify it for you.

How it compares with a book and with the assembler's own docs

The obvious alternative is a printed or ebook introduction to x86_64 assembly. The difference in approach is that a book is static while this repository is a set of Markdown files under version control with a link-checking workflow and an examples build workflow. When a URL in a post rots, the link checker is what surfaces it. That is a modest advantage, and it is the honest one: you get the course text plus a small, buildable example set in the same place.

The other alternative is the NASM documentation itself. NASM's manual describes the assembler, its directives and its syntax completely, and it is the authority the examples ultimately depend on. What it does not do is teach the Linux side: the README's topic list includes what a system call is and how your program interacts with an operating system, how a program for Linux is structured, and how floating point numbers are represented in memory. Those are the gaps this course fills, and they are the reason to read it alongside the assembler manual rather than instead of it.

One caution about search results: queries for "asm" also return Java bytecode tooling, Maven artifacts and unrelated products. Those are different projects that happen to share the name. This repository is the 0xAX one, and the README is the only description of it that counts.

Maintenance, releases and what the license means for reuse

The repository is not archived, and the last push was on 2026-09-19, with release v1.0.2 published the same day. The release cadence visible in the metadata is v1.0.0 on 2026-07-16, v1.0.1 on 2026-08-25 and v1.0.2 on 2026-09-19, which is a steady trickle rather than a burst. The README does not describe what each release contains, so the upgrade cost for a reader is simply re-reading the changed Markdown or downloading the latest PDF.

For a consumer of the material the upgrade surface is small: there is no dependency to bump, no API to migrate against. The cost sits on the other side, in contributions. CONTRIBUTING.md and CODE_OF_CONDUCT.md are both at the top level and the README points at them, so the process for sending changes is documented there rather than in the README itself.

The license is the part to think through. The README states that each Markdown file is licensed under CC BY-NC-SA 4.0. Attribution, non-commercial use and share-alike are the conditions. If your plan is to fold these chapters into a paid course or an internal product, that is a licensing question for your own review, not something this repository resolves for you. The translations linked from the README carry a note that they may diverge from the original content, so treat the English posts as the source of truth.

Editorial conclusion

Adopt 0xAX/asm if you want a short, guided path from a first syscall to calling assembly from C, and you are willing to install NASM and binutils and build the examples yourself. Do not adopt it if you need a maintained library, an ARM64 course (the README says ARM64 material is planned, not present), or content you can ship inside a commercial product under the CC BY-NC-SA 4.0 terms. Before committing, read content/asm_1.md and examples/hello/ to confirm the NASM syntax matches the assembler you use, and check the LICENSE and CONTRIBUTING.md for how reuse and contributions are handled.

Frequently asked questions

Official sources

1. 0xAX/asm on GitHub
2. Issues
3. Project website
4. README
5. Releases