⏱️ Lectura: 15 min
El Zilog Z80 cumplió 50 años este mes de julio de 2026: salió a la venta en julio de 1976, y Zilog recién lo descontinuó en 2024, apenas dos años antes de este aniversario. Durante medio siglo impulsó computadoras hogareñas, consolas, terminales y sistemas industriales que todavía siguen encendidos hoy.
📑 En este artículo
- TL;DR
- Qué es el Zilog Z80 y por qué importa
- Del Datapoint 2200 al Intel 8008: el origen accidental
- Arquitectura del Zilog Z80: registros, flags e interrupciones
- Ejemplos prácticos: de un programa mínimo a un caso real
- Cómo empezar: ensamblar y correr código Z80 hoy
- Casos de uso reales: dónde sigue vivo el Z80
- Errores comunes y buenas prácticas
- Comparativa: Z80 frente a otros microprocesadores de 8 bits
- Profundizando: instrucciones no documentadas y el eZ80
- Preguntas frecuentes
- Referencias
Este artículo explica cómo está construido por dentro el Zilog Z80, por qué nació casi por accidente como respuesta comercial a un chip que llegó tarde a su cliente original, y cómo podés escribir y ensamblar código para él en 2026 con herramientas gratuitas en Windows, macOS o Linux.
TL;DR
- Vas a entender por qué el Zilog Z80 es compatible en binario con el Intel 8080 y qué instrucciones nuevas agrega.
- Vas a distinguir el banco alterno de registros (AF’, BC’, DE’, HL’) y los registros de índice IX e IY.
- Vas a ensamblar tu primer programa Z80 con z88dk usando Docker en Windows, macOS o Linux.
- Vas a diferenciar los tres modos de interrupción del Z80 (IM0, IM1, IM2) y cuándo usar cada uno.
- Vas a usar instrucciones de bloque como LDIR para copiar memoria sin escribir un bucle manual.
- Vas a identificar dónde sigue el Z80 hoy: desde la Game Boy original hasta calculadoras TI y control industrial.
- Vas a entender por qué Zilog descontinuó el Z80 original en 2024 pero mantiene vivo el eZ80.
Qué es el Zilog Z80 y por qué importa
El Zilog Z80 es un microprocesador de 8 bits lanzado en julio de 1976 por Zilog, una empresa fundada por exingenieros de Intel. Es compatible en binario con el Intel 8080: cualquier programa escrito para el 8080 corre sin cambios en un Z80.
Esa compatibilidad no fue casualidad. Zilog diseñó el Z80 para capturar la base instalada de software del 8080 y superarlo en velocidad, funciones y costo de sistema. El chip integra el circuito de refresco de memoria DRAM que en un diseño con 8080 requería lógica externa adicional, así que una placa basada en Z80 necesitaba menos chips de soporte.
Junto al Intel 8080 y al 8085, el Z80 ayudó a crear un estándar de facto para microcomputadoras de 8 bits. Ese estándar de hardware permitió, a su vez, un estándar de software: el sistema operativo CP/M y el intérprete Microsoft BASIC corrían prácticamente igual en máquinas de distintos fabricantes.
Del Datapoint 2200 al Intel 8008: el origen accidental
La historia del Z80 empieza antes de que existiera Zilog, con una terminal programable. Computer Terminal Corporation (CTC) construyó la Datapoint 2200, una terminal con un procesador de 8 bits armado a partir de chips TTL individuales. Intel le vendía a CTC los registros de desplazamiento y la memoria para ese diseño.
En algún momento surgió la idea de reemplazar parte de esa lógica TTL con circuitos integrados a medida, y finalmente de meter toda la CPU de 8 bits en un solo chip. CTC contrató a dos empresas para intentarlo: Texas Instruments e Intel.
Ninguna terminó a tiempo. Cuando Intel tuvo listo su chip (llamado internamente 1201 según su convención de numeración), CTC ya vendía terminales con el diseño TTL original y además había rediseñado la arquitectura para la siguiente generación.
Texas Instruments abandonó su versión. Intel, en cambio, siguió adelante y comercializó la suya como el 8008 (con ese nombre de marketing, igual que hizo con el 4004). De ahí nacería, unos años después, el 8080, y de ese linaje saldría el Z80.
flowchart LR
A["Datapoint 2200 (CTC, logica TTL)"] --> B["Intel 8008 (1972)"]
B --> C["Intel 8080 (1974)"]
C --> D["Zilog Z80 (1976)"]
D --> E["Sharp LR35902 (Game Boy, 1989)"]
D --> F["eZ80 (Zilog, anos 2000)"]
Arquitectura del Zilog Z80: registros, flags e interrupciones
El Z80 hereda del 8080 un acumulador A y seis registros de propósito general (B, C, D, E, H, L), que se pueden usar solos (de 8 bits) o combinados en pares de 16 bits (BC, DE, HL). El par HL funciona además como puntero de memoria.
Lo que el Z80 agrega, y que el 8080 no tenía, es un segundo banco completo de registros: AF’, BC’, DE’ y HL’. Con una sola instrucción (EXX, o EX AF,AF’) el programa intercambia todo un banco por el otro, útil para rutinas de interrupción rápidas que no quieren pisar el contexto del programa principal.
También suma dos registros de índice de 16 bits, IX e IY, pensados para direccionamiento indexado: acceder a memoria con un desplazamiento fijo respecto a una base, típico de arreglos y estructuras.
El registro de banderas F guarda el estado de la ALU tras cada operación: Zero, Carry, Sign, Parity/Overflow y medio acarreo. El Z80 conserva además dos bits no documentados oficialmente (posiciones 3 y 5) que reflejan bits internos del resultado; varios programas de la escena demoscene y algunos emuladores dependen de imitarlos con precisión.
Para interrupciones, el Z80 define tres modos: IM0 (el periférico coloca la instrucción a ejecutar en el bus, como en el 8080), IM1 (siempre salta a la dirección fija 0x0038) e IM2 (el periférico aporta 8 bits que, junto al registro I, arman una tabla de 128 vectores de 16 bits). IM2 es el modo más flexible y el que usan la mayoría de las computadoras domésticas basadas en Z80.
flowchart TD
A["Acumulador A"] --- F["Flags F"]
B["Registro B"] --- C["Registro C"]
D["Registro D"] --- E["Registro E"]
subgraph "Par HL: puntero a memoria"
H["Registro H"] --- L["Registro L"]
end
IX["Indice IX"]
IY["Indice IY"]
SP["Puntero de pila SP"]
PC["Contador de programa PC"]
sequenceDiagram
participant CPU as Z80
participant PER as Periferico
PER->>CPU: solicita interrupcion (INT)
CPU->>CPU: termina la instruccion actual
CPU->>PER: reconoce con IORQ y M1
Note over CPU,PER: en modo IM2 la CPU arma un vector de 16 bits
CPU->>CPU: salta a la rutina de servicio
CPU-->>PER: ejecuta RETI al terminar
Ejemplos prácticos: de un programa mínimo a un caso real
Vamos a ver tres ejemplos progresivos: uno mínimo en ensamblador, uno que usa una instrucción exclusiva del Z80 para copiar memoria, y uno en C compilado para CP/M.
El primero carga un valor en el acumulador y lo envía a un puerto de entrada/salida:
ORG 0x0000
START:
LD A, 0x48 ; carga el caracter 'H' en el acumulador
OUT (0x01), A ; envia A al puerto de E/S numero 1
HALT ; detiene la CPU hasta la proxima interrupcion
Este programa no imprime nada por sí solo: en hardware real, el puerto 0x01 tendría que estar conectado a algo que interprete ese byte (una UART, un display). Lo importante es ver el patrón básico: LD para mover datos, OUT para hablarle a un periférico y HALT para detener el reloj de instrucciones.
El segundo ejemplo usa una de las instrucciones que hicieron famoso al Z80 frente al 8080: LDIR, que copia un bloque completo de memoria sin necesidad de escribir un bucle manual.
LD HL, 0x8000 ; direccion de origen
LD DE, 0xA000 ; direccion de destino
LD BC, 0x0100 ; 256 bytes a copiar
LDIR ; copia (HL) en (DE), incrementa HL y DE,
; decrementa BC y repite hasta BC = 0
Una sola instrucción reemplaza lo que en el 8080 requería cuatro o cinco instrucciones dentro de un bucle. El Z80 tiene toda una familia de instrucciones de bloque similares: LDDR (copia en reversa), CPIR (busca un byte) y INIR/OTIR (transferencia en bloque con E/S).
El tercer ejemplo muestra un caso más cercano a un programa real, escrito en C y compilado para CP/M con el toolchain z88dk:
#include <stdio.h>
int main(void) {
printf("Hola desde CP/M en un Z80\n");
return 0;
}
El compilador de z88dk traduce ese C a ensamblador Z80 y lo enlaza contra su runtime de CP/M. El resultado es un archivo .com que corre en cualquier emulador de CP/M o en hardware real con ese sistema operativo.
Cómo empezar: ensamblar y correr código Z80 hoy
La forma más simple de probar estos ejemplos sin instalar algo distinto según el sistema operativo es con Docker, que ejecuta el mismo comando en Windows, macOS y Linux (en Windows, a través de Docker Desktop con el backend de WSL2).
# Windows (Docker Desktop + WSL2), macOS y Linux: el mismo comando
docker pull z88dk/z88dk
docker run --rm -v "$PWD":/src z88dk/z88dk zcc +cpm -create-app -o hola.com /src/hola.c
La opción +cpm le indica a zcc que compile para la plataforma CP/M; -create-app arma el binario ejecutable. El resultado, hola.com, queda en tu carpeta local gracias al volumen montado con -v.
Para correr el binario sin hardware real hace falta un emulador de CP/M o de Z80. Una alternativa sin instalar nada es 8bitworkshop.com, un IDE en el navegador que ensambla y ejecuta código para Z80 y otras CPUs retro directamente, útil para probar los dos primeros ejemplos de este artículo sin salir del navegador.
💡 Tip: si vas a depurar interrupciones o el comportamiento exacto de los bits no documentados del registro F, usá un emulador con verificación ciclo a ciclo en vez de uno que solo simule la lógica funcional.
Casos de uso reales: dónde sigue vivo el Z80
El Z80 fue el corazón de computadoras hogareñas como la ZX Spectrum y de todo el estándar MSX, dos líneas que definieron la computación doméstica en Europa y Japón durante los años 80. También corrió CP/M en miles de sistemas de oficina antes de la llegada masiva del PC de IBM.
Su influencia llega hasta el bolsillo: el Sharp LR35902, el procesador de la Game Boy original, es un derivado del Z80 con un subconjunto de sus instrucciones y algunas del 8080. Millones de personas jugaron con un chip descendiente del Z80 sin saberlo.
Las calculadoras gráficas TI-83 y TI-84 de Texas Instruments, todavía usadas en escuelas de toda América Latina, también corren un Z80. Y en arcades clásicos de los 80 el Z80 solía manejar el sonido mientras otro procesador manejaba los gráficos.
Fuera del mundo retro, el Z80 original siguió fabricándose para aplicaciones industriales y embebidas hasta que Zilog lo descontinuó en 2024. La compañía no abandonó la arquitectura: la sucesora, el eZ80, sigue en producción con un pipeline de instrucciones y velocidades de reloj mucho más altas, apuntada al mismo tipo de control industrial.
Errores comunes y buenas prácticas
Un error frecuente al portar código del 8080 al Z80 es asumir que las banderas se comportan idéntico en toda instrucción nueva. La mayoría del subconjunto del 8080 sí es idéntico, pero algunas instrucciones exclusivas del Z80 fijan las banderas de formas distintas a lo que un programador acostumbrado al 8080 esperaría.
Otro error, más de hardware que de software, es subestimar el circuito de reset. Un power-on reset poco confiable deja al Z80 arrancando en un estado indefinido de sus registros internos, algo que quien diseñe una placa propia con un Z80 real (no emulado) descubre rápido apenas prueba su primer prototipo.
⚠️ Ojo: en sistemas embebidos con muy poca RAM, una pila (stack) mal dimensionada que crece hacia las mismas direcciones que tus variables globales produce corrupción silenciosa: los síntomas aparecen lejos de la causa real.
El registro R, pensado originalmente para refrescar DRAM automáticamente, también se incrementa con cada instrucción ejecutada. Algunos programas de protección contra copia de los años 80 lo usaban como fuente de aleatoriedad o para detectar si el código corría dentro de un emulador, algo a tener en cuenta si estás emulando un juego viejo y el comportamiento no coincide con el original.
Comparativa: Z80 frente a otros microprocesadores de 8 bits
| Procesador | Año | Compatibilidad | Uso típico |
|---|---|---|---|
| Intel 8080 | 1974 | Base del set de instrucciones que hereda el Z80 | Altair 8800, primeras microcomputadoras |
| Intel 8085 | 1976 | Compatible con el 8080, integra reloj y control de bus | Sistemas embebidos económicos |
| Zilog Z80 | 1976 | Superset binario del 8080, agrega IX/IY y banco alterno | ZX Spectrum, MSX, CP/M, Game Boy (vía derivado) |
| MOS 6502 | 1975 | Arquitectura propia, no compatible con la familia 8080 | Apple II, Commodore 64, NES |
La columna que más pesa en la práctica es la de compatibilidad. El Z80 ganó terreno porque una empresa podía migrar su software de 8080 sin reescribirlo, y encima ganar instrucciones nuevas gratis. El 6502, en cambio, competía con un diseño distinto: menos registros pero un ciclo de instrucción más simple y barato de fabricar, lo que explica por qué dominó otro segmento de mercado casi en paralelo.
Profundizando: instrucciones no documentadas y el eZ80
Zilog nunca documentó oficialmente que los registros de índice IX e IY se pueden tratar como dos mitades de 8 bits independientes: IXH, IXL, IYH e IYL. El hardware sí lo permite, y generaciones de programadores de assembly en la escena de la Game Boy y del Spectrum explotaron esto para ahorrar registros en rutinas críticas de velocidad.
Ese tipo de comportamiento no documentado es también la razón por la que escribir un emulador de Z80 realmente preciso es mucho más difícil de lo que parece a primera vista: no alcanza con implementar el manual oficial, hay que replicar bits internos de la ALU que Zilog nunca prometió mantener estables.
💭 Clave: el eZ80 mantiene el mismo set de instrucciones que el Z80 original pero ejecuta cada instrucción con un pipeline interno, lo que le permite alcanzar velocidades de reloj mucho mayores sin romper compatibilidad binaria con software de los años 80.
El eZ80 es hoy la vía que usa Zilog para seguir vendiendo la arquitectura en control industrial: mismas instrucciones, mismo modelo mental para quien ya sabe programar un Z80, pero con un núcleo modernizado por dentro. Para quien aprende la arquitectura clásica primero, migrar a eZ80 más adelante resulta casi directo en términos de curva de aprendizaje.
📖 Resumen en Telegram: Ver resumen
Tu próximo paso: instalá z88dk con Docker, ensamblá el ejemplo de LDIR de este artículo y corrélo en 8bitworkshop.com para ver el bloque de memoria copiarse paso a paso en el depurador.
Preguntas frecuentes
¿Por qué se llama Z80 y no siguió la numeración de Intel?
Zilog era una empresa nueva, fundada por exingenieros de Intel, y eligió su propio esquema de nombres. La “Z” identifica a Zilog y “80” hace referencia al parentesco con el Intel 8080, del que el chip es compatible en binario.
¿El Zilog Z80 es compatible con el Intel 8080?
Sí, en binario: cualquier programa compilado para el 8080 corre sin modificaciones en un Z80. El Z80 agrega instrucciones, registros y modos de interrupción nuevos que el 8080 no tiene.
¿Qué diferencia al Z80 del Intel 8085?
Ambos son compatibles con el 8080 y salieron el mismo año, pero por caminos separados: el 8085 integra el generador de reloj y parte de la lógica de control de bus, mientras que el Z80 apostó por más registros (banco alterno, IX, IY) y un set de instrucciones más amplio.
¿Dónde se usa hoy el Zilog Z80?
El chip original ya no se fabrica desde 2024, pero su arquitectura sigue viva en el eZ80 para control industrial, y el diseño derivado Sharp LR35902 sigue siendo, de hecho, el procesador de millones de Game Boy originales que aún funcionan.
¿Qué es el eZ80 y en qué se diferencia del Z80 original?
Es la evolución de Zilog de la misma arquitectura: mantiene el set de instrucciones del Z80 pero lo ejecuta con un pipeline interno, lo que permite frecuencias de reloj más altas sin romper la compatibilidad con software existente.
¿Puedo programar un Z80 sin tener hardware real?
Sí. Con z88dk podés ensamblar o compilar código para Z80 en Windows, macOS o Linux usando Docker, y correrlo en un emulador de CP/M o en un IDE en el navegador como 8bitworkshop.com, sin necesidad de un chip físico.
Referencias
- goliath32.com: The Zilog Z80 has turned 50: artículo original en inglés que repasa la historia y arquitectura del Z80, con anécdotas de su desarrollo y de la escena de computación doméstica.
- Wikipedia: Zilog Z80: ficha técnica y línea de tiempo del procesador, incluyendo sus derivados y su uso en distintas plataformas.
- GitHub: z88dk: toolchain open source de compilador C, ensamblador y bibliotecas para desarrollar software para Z80 y arquitecturas relacionadas.
- 8bitworkshop.com: IDE en el navegador para ensamblar, compilar y depurar código de Z80 y otras CPUs retro sin instalar nada.
📱 ¿Te gusta este contenido? Únete a nuestro canal de Telegram @programacion donde publicamos a diario lo más relevante de tecnología, IA y desarrollo. Resúmenes rápidos, contenido fresco todos los días.
Imagen destacada: Foto de Zulfugar Karimov en Unsplash
0 Comentarios