Online x86 / x64 Assembler and Disassembler

Documentation & Help

Usage Guide

Instruction Reference

Example Code

History

How to Use This Tool

This tool allows you to convert between assembly language and machine code for x86 and x64 architectures.

Assemble Mode

In Assemble mode, you can type assembly instructions and convert them to machine code:

Enter assembly instructions using Intel syntax, one per line.
Select the target architecture (32-bit or 64-bit).
Click "Process" or toggle "Real-time" for immediate results.
The output will show the hexadecimal representation of each instruction.

Example: mov eax, 1 will be assembled to b801000000

Disassemble Mode

In Disassemble mode, you can convert machine code back to assembly:

Enter a hexadecimal string (e.g., b801000000).
Select the target architecture (32-bit or 64-bit).
Click "Process" or use "Real-time" mode.
The output will show the disassembled instructions with their memory offsets.

The tool automatically removes "0x" prefixes and spaces from your input.

Additional Features

Real-time processing: Toggle to see results as you type.
Examples: Load pre-configured examples to learn common patterns.
Copy Output: Quickly copy the result to your clipboard.
Save/Load: Save your work and load it later.
Instruction Explanation: Get explanations for what each instruction does.
Dark Mode: Toggle between light and dark themes.

Data Movement Instructions

Instruction	Description	Example
MOV	Move data between registers or load immediate data	mov eax, ebx
PUSH	Push data onto the stack	push eax
POP	Pop data from the stack	pop eax
LEA	Load effective address	lea eax, [ebx+8]

Arithmetic Instructions

Instruction	Description	Example
ADD	Add two operands	add eax, 5
SUB	Subtract second operand from first	sub ebx, eax
MUL	Unsigned multiply	mul ebx
DIV	Unsigned divide	div ecx
INC	Increment by 1	inc eax
DEC	Decrement by 1	dec eax

Logical Instructions

Instruction	Description	Example
AND	Bitwise AND	and eax, 0xFF
OR	Bitwise OR	or edx, ebx
XOR	Bitwise exclusive OR	xor eax, eax
NOT	Bitwise NOT	not eax

Control Flow Instructions

Instruction	Description	Example
JMP	Unconditional jump	jmp label
JE/JZ	Jump if equal/zero	je label
JNE/JNZ	Jump if not equal/not zero	jne label
CALL	Call procedure	call procedure
RET	Return from procedure	ret

Click on any example to load it into the editor:

Hello World (32-bit)

mov eax, 4 ; write mov ebx, 1 ; stdout mov ecx, msg ; buffer mov edx, len ; length int 0x80 ; syscall

Hello World (64-bit)

mov rax, 1 ; write mov rdi, 1 ; stdout mov rsi, msg ; buffer mov rdx, len ; length syscall

Simple Loop (32-bit)

mov ecx, 10 ; counter loop_start: dec ecx jnz loop_start ; repeat until zero

Arithmetic (64-bit)

mov rax, 100 add rax, 50 sub rax, 25 imul rax, 2

Function Example (32-bit)

push ebp ; save base pointer mov ebp, esp ; create stack frame sub esp, 8 ; allocate local variables mov eax, [ebp+8] ; get first parameter add eax, [ebp+12] ; add second parameter mov esp, ebp ; restore stack pointer pop ebp ; restore base pointer ret ; return

Branching (64-bit)

mov rax, 10 cmp rax, 5 jg greater ; jump if greater mov rbx, 0 jmp end greater: mov rbx, 1 end: mov rcx, rbx

Your recent operations will be saved here for quick reference:

No history yet. Process some code to create history entries.