Assembly language

Q: What is assembly language?

Assembly language is a human-readable form of machine code: each instruction is written as a short mnemonic (LOAD, ADD, STORE, HALT) with its operand, and an assembler translates each line one-to-one into the opcode byte the CPU executes. It is the thinnest layer over the hardware.

Q: What is an assembler?

An assembler is a program that turns assembly mnemonics into machine-code bytes. For each instruction it looks up the opcode and packs the operand after it, for example ADD 14 becomes byte 0x2E. It is the automated, error-proof version of assembling bytes by hand.

Q: What is the difference between assembly language and machine code?

They are the same instructions in two forms: machine code is the raw bytes the CPU runs (0x1E), assembly is the readable text a human writes (LOAD 14). The assembler converts assembly to machine code, and every assembly line corresponds to exactly one machine instruction.

Q: How is assembly different from a high-level language like C?

Assembly is one-to-one with machine code: each line is a single CPU instruction. A high-level language like C is many instructions per line, translated by a compiler, and hides the registers and addresses that assembly exposes directly.

Human-readable machine code

4 min read

Assembly language is a human-readable form of machine code in which each instruction is written as a short mnemonic (such as LOAD or ADD) that an assembler translates one-to-one into the opcode byte the CPU executes.

Builds onMachine code Tracing a program

You can now read and write machine code (the opcode/operand bytes) and you watched a program run through the machine. But writing programs as raw hex, 0x1E, 0x2F, 0x3D, is miserable and easy to get wrong. Assembly language fixes that: each instruction becomes a short mnemonic you can read, and an assembler turns the mnemonics back into the exact bytes. It is the thinnest possible layer over the hardware, one line per instruction.

Mnemonics: a name per opcode

Instead of memorising that 0x1 means load, you write LOAD. Each opcode in the machine's instruction set gets a name, its mnemonic, and the operand is written as a plain number. The four instructions of our accumulator machine:

mnemonic	opcode	what it does
LOAD addr	0x1	ACC <- memory[addr]
ADD addr	0x2	ACC <- ACC + memory[addr]
STORE addr	0x3	memory[addr] <- ACC
HALT	0xF	stop the clock

The instruction set, now with a mnemonic for each opcode. You write the left column; the assembler produces the byte from the opcode plus the operand.

The assembler: names back to bytes

An assembler is a tiny program that reads your mnemonics and emits bytes. For each line it looks up the opcode nibble for the mnemonic and packs the operand nibble after it, exactly the hand-assembly you did (ADD 14 becomes opcode 0x2, address 0xE, byte 0x2E), just automated. Here is the program you traced written in assembly, next to the bytes the assembler produces:

addr  byte   assembly       meaning
 0    0x1E   LOAD 14        ; ACC = mem[14]
 1    0x2F   ADD 15         ; ACC = ACC + mem[15]
 2    0x3D   STORE 13       ; mem[13] = ACC
 3    0xF0   HALT           ; stop

The same LOAD/ADD/STORE/HALT program, as assembly (right) and the bytes the assembler emits (middle). Line for line, one mnemonic becomes one byte. This is what makes it assembly, not a high-level language.

Read across a row: LOAD 14 is opcode 0x1 (LOAD) on operand 0xE (14), so the assembler writes the byte 0x1E. ADD 15 is 0x2 on 0xF, byte 0x2F. Every assembly line maps to exactly one byte, and you could disassemble the bytes straight back to the mnemonics. That one-to-one relationship is the defining feature of assembly language.

Why this matters: assembly is the boundary between software and hardware. Above it, high-level languages (C, Python) compile down to many assembly instructions per line; below it, the assembler's bytes are what the control unit actually decodes and runs. Everything a computer does is, at the bottom, a stream of these instructions. Writing a few by hand is how that stops being mysterious.

A comment (everything after ; here) is for you, not the machine: the assembler ignores it, so it never becomes a byte. Do not confuse the operand (a real number the assembler encodes) with a comment (ignored text). ADD 15 encodes the 15; ADD 15 ; add the tax still encodes only the 15.

Try it

Write the assembly line that stores the accumulator into address 9, and give the byte the assembler produces.

Frequently asked

What is assembly language?

Assembly language is a human-readable form of machine code: each instruction is written as a short mnemonic (LOAD, ADD, STORE, HALT) with its operand, and an assembler translates each line one-to-one into the opcode byte the CPU executes. It is the thinnest layer over the hardware.

What is an assembler?

An assembler is a program that turns assembly mnemonics into machine-code bytes. For each instruction it looks up the opcode and packs the operand after it, for example ADD 14 becomes byte 0x2E. It is the automated, error-proof version of assembling bytes by hand.

What is the difference between assembly language and machine code?

They are the same instructions in two forms: machine code is the raw bytes the CPU runs (0x1E), assembly is the readable text a human writes (LOAD 14). The assembler converts assembly to machine code, and every assembly line corresponds to exactly one machine instruction.

How is assembly different from a high-level language like C?

Assembly is one-to-one with machine code: each line is a single CPU instruction. A high-level language like C is many instructions per line, translated by a compiler, and hides the registers and addresses that assembly exposes directly.

Every lesson here builds toward one thing: a working CPU, from the transistor up.

Open the free lab →

Builds towardLabels and data