C64 muerta: emulé su CPU 6502 en WebAssembly

Revivir una Commodore 64 con un emulador casero: cómo construir tu propio ciclo de CPU 6502 en WebAssembly paso a paso

¿Te imaginas tener una Commodore 64 funcionando dentro de tu navegador, sin plugins, sin instalaciones raras, solo abriendo una pestaña? Pues eso hice yo. Y no, no usé un emulador ya hecho. Me construí mi propio ciclo de CPU 6502 en WebAssembly desde cero. Porque claro, ¿para qué hacerlo fácil cuando puedes hacerlo interesante?

Hoy te cuento cómo pasé de tener una Commodore 64 real con la pantalla en negro (bueno, con borde, pero sin mensaje de bienvenida) a revivirla en el navegador con un emulador casero. Y de paso, te explico por qué entender el ciclo de una CPU de los 70 te hace mejor developer hoy.

El caso: una Commodore 64 que se negaba a arrancar

Todo empezó con una Commodore 64 de segunda mano que compré en un mercadillo. El vendedor me dijo: "Funciona, pero a veces hace cosas raras". Traducción: no funciona. Y efectivamente, al encenderla, la pantalla mostraba el borde de color, pero ni mensaje de bienvenida ni cursor. Un clásico.

Lo primero que hice fue lo que haría cualquier persona con sentido común: buscar en foros. Y ahí me encontré con la sabiduría colectiva de gente que lleva décadas reviviendo estas máquinas. El diagnóstico típico: CPU, chip de vídeo, kernal o el PLA. Pero ninguno de esos era el problema.

Probé con un cartucho de juegos para descartar que fuera el BASIC. Nada. Luego usé un cartucho de diagnóstico que prueba RAM, integrados esenciales y lógica. Todo bien. Entonces probé otro cartucho más avanzado, este con test de teclado. Y ahí saltó la liebre: las teclas se activaban y desactivaban sin correspondencia, y luego el sistema se colgaba.

Causa identificada: uno de los dos integrados CIA (los que gestionan, entre otras cosas, la entrada por teclado) estaba muerto. La solución temporal: quitarlos. La máquina arrancó sin ellos (solo perdía el cursor en pantalla). Confirmado.

Lección clave: si hubiera empezado quitando los CIA y el chip de sonido, me habría ahorrado horas. Porque no son esenciales para el arranque. Pero bueno, así es como se aprende.

De la reparación física al emulador casero en WebAssembly

Aquí es donde la cosa se pone interesante. Tenía la Commodore 64 reparada (o al menos, arrancando). Pero me picó la curiosidad: ¿y si pudiera emularla en el navegador? No con un emulador ya hecho, sino construyendo mi propio ciclo de CPU 6502 en WebAssembly. Porque sí, soy así de intensa.

Paso 1: Entender qué es un ciclo de CPU

Un ciclo de CPU es como el latido del corazón de un procesador. En el caso del 6502, cada instrucción se ejecuta en una serie de pasos: fetch (traer), decode (decodificar), execute (ejecutar). Y todo eso ocurre en ciclos de reloj. Si no entiendes esto, no puedes emular nada.

Así que me puse a leer. Mucho. Documentación técnica, foros, vídeos de gente que ya lo había hecho. Y descubrí que el 6502 es una joya de la simplicidad. Tiene 56 instrucciones, 13 modos de direccionamiento y un montón de trucos que los programadores de la época usaban para exprimir cada ciclo.

Paso 2: Elegir WebAssembly como target

¿Por qué WebAssembly? Porque quería que el emulador corriera en cualquier navegador, sin depender de JavaScript puro (que para estas cosas es lento). WebAssembly te da rendimiento casi nativo y portabilidad total. Además, mola decir que has escrito un emulador en WebAssembly.

Paso 3: Construir el ciclo de CPU paso a paso

Aquí viene lo bueno. El ciclo básico es:

1. Fetch: leer el byte en la dirección de memoria apuntada por el contador de programa (PC).
2. Decode: identificar qué instrucción es.
3. Execute: ejecutar la instrucción, actualizar registros y memoria.
4. Incrementar PC: pasar a la siguiente instrucción (o saltar, si es un branch).

En WebAssembly, esto se traduce en un bucle que lee de la memoria (un array de bytes), decodifica con un switch gigante (o una tabla de funciones) y ejecuta. Suena simple, pero hay que gestionar los flags, los modos de direccionamiento, los ciclos exactos... Un dolor de cabeza precioso.

Paso 4: Los modos de direccionamiento, esos grandes olvidados

El 6502 tiene 13 modos de direccionamiento. Desde el implícito (no necesita operando) hasta el indirecto indexado (que es como el primo complicado de la familia). Cada uno afecta a cómo se obtiene el operando y a cuántos ciclos tarda la instrucción.

Implementarlos todos fue como montar un mueble de esos que vienen sin instrucciones. Pero cuando lo logras, sientes que puedes con todo.

Paso 5: Integrar la CPU con el resto del sistema

Un emulador no es solo la CPU. Necesitas emular la memoria, el chip de vídeo, el de sonido, los CIA... Pero para el primer prototipo, me centré en la CPU y la memoria. Suficiente para ejecutar pequeños programas en código máquina.

Y ahí estaba: mi ciclo de CPU 6502 en WebAssembly, ejecutando instrucciones en el navegador. No era una Commodore 64 completa, pero era el corazón. Y funcionaba.

La lección: entender la máquina te hace mejor developer

Construir un emulador de CPU no es solo un ejercicio de nostalgia. Es una lección de humildad y de comprensión profunda. Cuando escribes código en un lenguaje moderno, das por sentadas millones de cosas: la gestión de memoria, los ciclos de reloj, los registros... Pero cuando emulas una CPU de los 70, te das cuenta de que todo eso es magia construida sobre fundamentos muy simples.

Además, te obliga a pensar en eficiencia. Cada ciclo cuenta. Cada byte importa. Y eso se traduce en un mejor código en tu día a día, incluso si trabajas en aplicaciones web modernas.

Y sí, también tiene un punto de rebeldía. En una época en la que todo es abstracción sobre abstracción, volver al metal (aunque sea emulado) es casi un acto revolucionario.

Reflexión final: ¿por qué revivir una Commodore 64 en 2026?

Porque la tecnología no es solo lo nuevo. Es también lo viejo que sigue funcionando. Es entender de dónde venimos para saber a dónde vamos. Y porque, seamos sinceros, ver arrancar una Commodore 64 en tu navegador con tu propio emulador casero es una satisfacción que no te da ninguna app de moda.

Así que te lanzo la pregunta: ¿te atreverías a construir tu propio emulador? No tiene que ser una Commodore 64. Puede ser una Game Boy, una NES o incluso una máquina imaginaria. El reto no es el hardware, es entender cómo funciona por dentro. Y cuando lo logras, no hay vuelta atrás.

¿Te animas a ensuciarte las manos con WebAssembly y un viejo manual del 6502? Cuéntamelo en los comentarios. Prometo no juzgar si tu primer intento solo hace parpadear un LED.