Menu
CoddyTech

¿Qué es el lenguaje ensamblador (Assembly)?

El lenguaje ensamblador (Assembly) es un lenguaje de programación de bajo nivel en el que las instrucciones de un procesador se escriben una por línea, con nombres cortos como mov y add en lugar de números binarios. Un programa llamado ensamblador lo traduce al código máquina que ejecuta la CPU.

Por Kevin Spektor, Cofundador y CTO

Actualizado el 16 de noviembre de 2026

Este programa imprime una línea. Pulsa Ejecutar: se ensambla con NASM, se enlaza como un programa de Linux y se ejecuta. Habla directamente con Linux mediante llamadas al sistema, sin la biblioteca de C.

Hello from assembly!

Cada línea bajo _start es una instrucción para un procesador x86-64, el tipo que llevan la mayoría de los PC con Windows y Linux. No hay ninguna función print. El programa pone cuatro números en los registros del procesador y le pide al núcleo de Linux que escriba los bytes.

Leer el programa línea a línea

section .data abre la parte del programa que guarda datos fijos. msg db "Hello from assembly!", 10 reserva bytes para el texto, y db significa "define bytes" (definir bytes). El 10 del final es el código de carácter de un salto de línea.

len equ $ - msg lo calcula el ensamblador, no el procesador: $ es la posición actual, así que la diferencia es la longitud del mensaje, 21 bytes.

section .text contiene las instrucciones. global _start hace que la etiqueta _start sea visible para el enlazador, que la marca como el punto donde empieza el programa.

mov rax, 1 copia el número 1 en el registro rax. Un registro es una pequeña casilla de almacenamiento dentro del propio procesador, de 64 bits de ancho en x86-64, y la mayoría de los cálculos ocurren en registros. Las tres líneas mov siguientes llenan rdi, rsi y rdx de la misma forma.

syscall cede el control al sistema operativo. Linux mira rax para saber qué servicio se pide (1 es write) y rdi, rsi y rdx para sus argumentos: dónde escribir, la dirección de los bytes y cuántos son. La segunda syscall, con 60 en rax, termina el programa con el código de salida 0.

Las palabras después de ; son comentarios. El ensamblador los ignora, y en ensamblador importan más que en la mayoría de los lenguajes, porque las instrucciones dicen qué pasa pero no por qué.

Cómo el ensamblador se convierte en un programa

El procesador no puede leer el texto de arriba. Un ensamblador lo traduce a código máquina, y un enlazador convierte el resultado en un archivo que el sistema operativo puede ejecutar:

  1. El ensamblador (nasm -f elf64 hello.asm -o hello.o) traduce cada instrucción a sus bytes y escribe un archivo objeto.
  2. El enlazador (ld hello.o -o hello) rellena las direcciones de memoria definitivas, como dónde estará msg, y escribe el ejecutable.
  3. Al ejecutar ./hello, el núcleo carga esos bytes en memoria y pone en marcha el procesador en _start.

Un desensamblador muestra lo que produjo el ensamblador. Esta es la salida de objdump -d -M intel hello.o, recortada a las tres primeras instrucciones:

0000000000000000 <_start>:
   0:   b8 01 00 00 00          mov    eax,0x1
   5:   bf 01 00 00 00          mov    edi,0x1
   a:   48 be 00 00 00 00 00    movabs rsi,0x0
  11:   00 00 00

Cada línea de ensamblador se convirtió en una instrucción de 2 a 10 bytes. Dos detalles muestran que el ensamblador hace algo más que copiar: NASM eligió una codificación más corta para mov rax, 1, ya que escribir en eax también borra la mitad superior de rax, y la dirección de msg sigue siendo todo ceros porque solo el enlazador la conoce. La página de código máquina lee estos bytes uno a uno.

Esta es la diferencia con un compilador. Un compilador parte de un lenguaje como C, donde una línea puede convertirse en muchas instrucciones, y elige esas instrucciones por su cuenta. En ensamblador, eliges tú cada instrucción.

Los registros hacen el trabajo

El ensamblador no tiene variables declaradas con tipos, como las de Python o C. Tú decides dónde vive cada valor: en un registro mientras el procesador trabaja con él, o en memoria, donde una etiqueta como digit da nombre a la dirección. Este programa suma dos números e imprime el resultado:

7

La suma es el número 7, pero la pantalla muestra caracteres, así que el programa suma 48, el código del carácter 0, antes de escribirlo. al es el byte más bajo de rax, y [digit] con corchetes significa "la memoria en la dirección digit". Cambia el 5 por 15 y la salida es A, el carácter con código 65: imprimir un número de dos cifras requiere un bucle que divida entre 10. Ahí está el compromiso del ensamblador en un solo ejemplo. Controlas cada paso, y tienes que escribir cada paso.

Un lenguaje ensamblador por cada familia de procesadores

El ensamblador no es un único lenguaje. Cada familia de procesadores tiene sus propias instrucciones, registros y reglas, y el código escrito para una no funciona en otra. Esta es la misma operación, "poner 1 en el registro del primer argumento", en tres de ellos:

x86-64 (NASM):  mov rdi, 1
ARM64:          mov x0, #1
RISC-V:         li a0, 1
  • x86-64 funciona en la mayoría de los PC y servidores con Windows y Linux, con procesadores Intel y AMD. Sus dos sintaxis ponen los operandos en orden opuesto: la sintaxis Intel escribe mov rax, 1, y la sintaxis AT&T, la predeterminada de las herramientas de GNU, escribe movq $1, %rax.
  • ARM64, también llamado AArch64, funciona en casi todos los móviles, en los Mac con Apple silicon y en una parte creciente de los servidores en la nube.
  • RISC-V es un conjunto de instrucciones abierto, habitual en microcontroladores y en la enseñanza.

Familias más antiguas como el 8086, el 6502 y MIPS se siguen enseñando en las universidades porque son pequeñas. Las ideas se trasladan entre todas ellas: registros, direcciones de memoria, comparar y saltar.

Para qué se usa el lenguaje ensamblador

  • Sistemas operativos. El código que arranca el procesador, gestiona las interrupciones y cambia de un programa a otro está escrito en parte en ensamblador. El núcleo de Linux lo guarda en una carpeta aparte para cada familia de procesadores.
  • Bucles donde la velocidad es crítica. Decodificadores de vídeo como dav1d y herramientas multimedia como FFmpeg usan ensamblador escrito a mano en los pocos bucles donde pasan la mayor parte del tiempo.
  • Sistemas embebidos. Los chips muy pequeños, con unos pocos kilobytes de memoria, a veces necesitan código en el que se elige cada byte.
  • Leer lo que generó un compilador. gcc -S y sitios como Compiler Explorer muestran el ensamblador que hay detrás del código en C, C++ o Rust, y así es como la gente comprueba las optimizaciones.
  • Seguridad e ingeniería inversa. Un programa sin su código fuente se puede desensamblar igualmente, y así es como lo leen los analistas de malware y los desarrolladores de exploits.
  • Aprender cómo funcionan los ordenadores. Un segmentation fault, un desbordamiento de pila o un puntero tienen mucho más sentido después de escribir las instrucciones que hay detrás.

Mitos comunes sobre el ensamblador

  • "El ensamblador es código máquina." Es texto que se corresponde de cerca con el código máquina. Las etiquetas, los comentarios, db y equ existen solo para el ensamblador, y este elige las codificaciones por ti, como mostró mov rax, 1.
  • "El ensamblador siempre es más rápido." El código es tan rápido como las instrucciones elegidas, y los compiladores modernos eligen muy bien. El ensamblador escrito a mano gana en casos concretos, normalmente bucles que usan instrucciones especiales, y quienes lo escriben miden primero.
  • "Necesitas aprender ensamblador antes que cualquier otro lenguaje." No. Es un buen segundo o tercer lenguaje: cuando ya sabes qué son una variable y un bucle, es más fácil ver cómo los ejecuta el procesador.

Por dónde seguir

Prueba a cambiar los programas de arriba en el playground de Assembly, que usa la misma cadena de herramientas x86-64 NASM. La hoja de trucos de Assembly reúne los registros, las instrucciones y las llamadas al sistema de Linux en una sola página. Para ver en detalle lo que produce el ensamblador, lee qué es el código máquina, y para practicar paso a paso los registros, la memoria, las llamadas al sistema, la aritmética y los bucles, haz el curso gratuito de Assembly.

Preguntas frecuentes

¿Se sigue usando el lenguaje ensamblador hoy en día?

Sí, pero en lugares pequeños y concretos. Los núcleos de los sistemas operativos lo usan para el código que arranca el procesador y cambia de un programa a otro, el firmware de chips diminutos lo usa donde cuenta cada byte, y decodificadores de vídeo como dav1d usan ensamblador escrito a mano en sus bucles más intensos. Muchos desarrolladores que nunca lo escriben sí lo leen, al depurar un fallo, revisar lo que produjo un compilador o analizar malware.

¿Es el ensamblador más difícil que C++?
El lenguaje en sí es más pequeño: unas pocas decenas de instrucciones comunes, registros y memoria. Escribir un programa completo es más difícil, porque tú gestionas los registros, la memoria y el flujo de control. No hay tipos, ni sentencias de bucle, ni print, así que una sola línea de C++ puede ocupar diez líneas de ensamblador.
¿Qué diferencia hay entre el lenguaje ensamblador y un programa ensamblador?
Assembly es el lenguaje: el texto que escribes, como mov rax, 1. Un ensamblador es el programa que traduce ese texto a código máquina, como NASM, el ensamblador de GNU as o MASM de Microsoft. Mucha gente también llama "ensamblador" (assembler) al lenguaje, sobre todo en alemán, ruso y polaco, donde es el nombre habitual.
¿C++ es un lenguaje ensamblador?
No. C++ es un lenguaje de alto nivel: lo traduce un compilador, y una línea puede convertirse en muchas instrucciones de máquina, que el compilador puede generar para cada familia de procesadores que admite. El ensamblador está ligado a una familia de procesadores, y cada línea es una instrucción. Compiladores como GCC pueden mostrarte el ensamblador que generan para tu código C++ con la opción -S.
¿Cuántos lenguajes ensambladores hay?

Uno por cada familia de procesadores, además de distintas sintaxis para algunas de ellas. Los más comunes hoy son x86-64 para los PC con Intel y AMD, ARM64 para los móviles y los Mac con Apple silicon, y RISC-V. Solo para x86-64 hay dos sintaxis: Intel (la que usan NASM y MASM) y AT&T (la predeterminada del ensamblador de GNU).

Ilustración de los lenguajes de programación de Coddy

Aprende a programar con Coddy

Comenzar