Free Online Assembly Compiler & 8086 Simulator

Learn assembly here, from zero

Everything below lives on this page on purpose. Read a section, scroll up, press Step, and watch the registers do what the text just described. Ten minutes of that beats an hour of reading, and nothing here needs an install or an account.

Your first program, line by line

This is the example waiting in the editor. It prints a string and stops. The comments tell you what each line does; here is the why.

ORG 0100h            ; programs load at address 0100h here

    MOV DX, msg      ; put the ADDRESS of the text in DX
    MOV AH, 09h      ; pick DOS service 09h: "print a string"
    INT 21h          ; hand control to DOS (the simulator)

    MOV AH, 4Ch      ; pick service 4Ch: "end the program"
    INT 21h

msg DB "Hello, World!$"   ; the bytes of the text, $ ends it

Two ideas carry the whole program. First, DX does not hold the text itself, it holds where the text lives, which is why msg can sit at the bottom of the file. Second, INT 21h is a service desk: the number in AH chooses the service, DX or DL passes any extra information, and the call does the work. Press Step on this program and watch AX, DX and IP change line by line.

Meet the registers

A register is a tiny storage box inside the processor, and assembly is mostly moving numbers between boxes. Each 16-bit register splits into two 8-bit halves, so AX contains AH (high half) and AL (low half). The register panel shows both halves at all times.

• AXthe arithmetic register. division and multiplication use it automatically, and its AL half receives characters from input.
• BXa general workhorse, often used to hold addresses.
• CXthe counting register. LOOP counts it down automatically, so loops live here.
• DXdata mover. string printing expects a string's address here, and DL carries single characters out.
• SI, DIsource and destination pointers for walking through strings.
• SP, BPstack bookkeeping. CALL and PUSH/POP use SP without you touching it.

The instructions worth memorizing first

Twelve lines of vocabulary cover most beginner programs. The full list the simulator accepts is longer, but these are the ones the exercises use.

Practice: five exercises

Each exercise adds one idea. Try it in the editor first; every solution is checked against this exact simulator, so if yours prints the same thing, it counts. Reading a hint after two honest minutes is studying, not cheating.

1. 1Print your own name

   The loaded example prints "Hello, World!". Change it so the program prints your name instead. One string, one print, one exit.

   Show a hint

   You only need to edit the DB line. The string must end with $ or the print will run on into whatever bytes come next.

   Show the solution

   ORG 0100h
   
       MOV DX, name    ; DX = address of the text
       MOV AH, 09h     ; print a $-terminated string
       INT 21h
   
       MOV AH, 4Ch     ; end the program
       INT 21h
   
   name DB "Riya$"    ; <- put your name here, keep the $

2. 2Countdown from 9 to 1

   Print the digits 9, 8, 7 ... 1 on one line. This flips the counting example: instead of INC BL you DEC BL, and CX starts at 9.

   Show a hint

   Start BL one PAST the first character you want (':' comes after '9'), then DEC before each print.

   Show the solution

   ORG 0100h
   
       MOV CX, 9       ; nine digits to print
       MOV BL, ':'     ; one past '9'
   top:
       DEC BL          ; ':' -> '9' -> '8' -> ...
       MOV DL, BL
       MOV AH, 02h     ; print the character in DL
       INT 21h
       LOOP top        ; CX = CX-1, repeat while CX > 0
   
       MOV AH, 4Ch
       INT 21h

3. 3Add two numbers stored in memory

   Store 4 and 5 with two DB lines, add them, and print the single-digit result. This is the first program that reads data from memory.

   Show a hint

   [A] means the value stored at A (the brackets matter: without them you would get A's address). A digit character is the value plus '0'.

   Show the solution

   ORG 0100h
   
       MOV AL, [A]     ; AL = the byte stored at A
       ADD AL, [B]     ; AL = 4 + 5 = 9
       ADD AL, '0'     ; 9 -> the character "9"
       MOV DL, AL
       MOV AH, 02h
       INT 21h
   
       MOV AH, 4Ch
       INT 21h
   
   A DB 4
   B DB 5

4. 4Print two strings on separate lines

   Print FIRST, then a newline, then SECOND. There is no println in DOS, so a newline is two characters you print yourself: 0Dh (carriage return) and 0Ah (line feed).

   Show a hint

   Print the first string with AH=09h, then use AH=02h twice for 0Dh and 0Ah, then print the second string.

   Show the solution

   ORG 0100h
   
       MOV DX, first
       MOV AH, 09h     ; print FIRST
       INT 21h
   
       MOV DL, 0Dh     ; carriage return
       MOV AH, 02h
       INT 21h
       MOV DL, 0Ah     ; line feed
       INT 21h
   
       MOV DX, second
       MOV AH, 09h     ; print SECOND
       INT 21h
   
       MOV AH, 4Ch
       INT 21h
   
   first  DB "FIRST$"
   second DB "SECOND$"

5. 5Count the characters in a string

   Walk the string SCRAMBLE one byte at a time until you hit $, count the steps in CX, then print the count. This combines pointers, compares, a loop and printing into one program.

   Show a hint

   Use SI as the pointer and CX as the counter. Compare [SI] with '$' and jump out when equal; otherwise INC both and loop. Print CL at the end (it fits, the word is short).

   Show the solution

   ORG 0100h
   
       MOV SI, word    ; SI points at the first character
       MOV CX, 0       ; the counter
   next:
       MOV AL, [SI]    ; read the character SI points at
       CMP AL, '$'     ; end of the string?
       JE done
       INC CX          ; one more character
       INC SI          ; move to the next one
       JMP next
   
   done:
       MOV DL, CL      ; print the count as a digit
       ADD DL, '0'
       MOV AH, 02h
       INT 21h
   
       MOV AH, 4Ch
       INT 21h
   
   word DB "SCRAMBLE$"

When the five exercises feel comfortable, you know more assembly than most people who claim to know it: registers, flags, jumps, loops, memory addressing and the DOS print services. From there, good next steps are the stack (PUSH, POP, CALL) and string handling with SI and DI, both practiced right in the editor above. Curious how another language runs without an install? The Python playground runs real CPython the same way.