Assembly Playground

Escribe, ejecuta y comparte fragmentos de código, sin instalaciones.

main.asm

Alice

Output

Click Run to see the output here.

section .data
    prompt db 'Hello, '
    prompt_len equ $ - prompt
    bang db '!', 10
    bang_len equ $ - bang

section .bss
    name resb 64

section .text
    global _start

_start:
    ; read up to 63 bytes of the name from stdin (fd 0)
    mov rax, 0          ; sys_read
    mov rdi, 0          ; stdin
    mov rsi, name
    mov rdx, 63
    syscall
    mov r12, rax        ; bytes read

    ; drop the trailing newline if present
    cmp r12, 0
    jle no_trim
    mov bl, [name + r12 - 1]
    cmp bl, 10
    jne no_trim
    dec r12
no_trim:

    ; write "Hello, "
    mov rax, 1          ; sys_write
    mov rdi, 1          ; stdout
    mov rsi, prompt
    mov rdx, prompt_len
    syscall

    ; write the name
    mov rax, 1
    mov rdi, 1
    mov rsi, name
    mov rdx, r12
    syscall

    ; write "!\n"
    mov rax, 1
    mov rdi, 1
    mov rsi, bang
    mov rdx, bang_len
    syscall

    ; exit(0)
    mov rax, 60         ; sys_exit
    xor rdi, rdi
    syscall

Ejecuta Assembly online en tu navegador

Este es un compilador Assembly online y gratuito para código x86-64 escrito en sintaxis NASM. Escribe tu programa, pulsa Ejecutar y Coddy lo ensambla con nasm -f elf64, lo enlaza con ld y ejecuta el ejecutable de Linux resultante en el servidor; luego te muestra stdout, stderr y el código de salida. No hay nada que instalar: ni NASM, ni enlazador, ni máquina virtual, ni compilador cruzado.

El programa inicial es un punto de entrada _start completo que lee una línea de la entrada estándar y devuelve un saludo usando las syscalls crudas read, write y exit, sin libc. Así funciona el ensamblador de verdad: colocas los argumentos en rax/rdi/rsi/rdx, invocas syscall y el kernel hace el resto. Usa el panel de stdin debajo del editor para pasar entrada a tu programa en cada Ejecución, igual que redirigir datos a un binario real.

Qué hace útil a este playground de Assembly

Cadena de herramientas NASM x86-64 real. Tu código fuente se ensambla con nasm -f elf64 y se enlaza con ld en Linux, los mismos comandos que escribirías localmente, así que lo que se ejecuta aquí coincide con lo que se ejecuta en una máquina real.
Syscalls directas de Linux. El programa inicial usa read, write y exit mediante la instrucción syscall sin libc de por medio, así que ves exactamente cómo los registros transportan los argumentos y los valores de retorno.
Compatibilidad con la entrada estándar. Envía bytes a tu programa a través del panel de stdin y léelos con la syscall 0: útil para los ejercicios clásicos de 'leer un nombre e imprimir un saludo' y más allá.
Sin configuración, respuesta instantánea. Sin instalar NASM, sin flags del enlazador que recordar, sin errores de permisos: abre la página y el editor está listo. Los errores del ensamblador y del enlazador vuelven directamente en la salida.

Qué puedes probar en el playground de Assembly

Imprime una cadena fija con una sola syscall write y luego un exit(0) limpio: el programa x86-64 completo más pequeño y la forma más rápida de ver cómo encajan _start y syscall.
Lee de stdin en un búfer .bss, recorta el salto de línea final y devuélvelo: el patrón detrás de casi todos los ejercicios de ensamblador basados en entrada.
Suma dos números en registros y convierte el resultado a dígitos ASCII a mano para poder hacer write. Así aprendes que en ensamblador no hay print, solo bytes y syscalls.

Preguntas frecuentes del compilador Assembly online

¿Qué ensamblador y sintaxis usa este playground?

Usa NASM (el Netwide Assembler) con sintaxis Intel, dirigido a x86-64 Linux. Tu código se ensambla con nasm -f elf64 y se enlaza con ld. Si vienes de la sintaxis AT&T/GAS (el estilo %rax, movq), reescríbelo en el estilo Intel de NASM: mov rax, 1, section .text, global _start.

¿Necesito instalar NASM o un enlazador para usar esto?

No. La cadena de herramientas completa se ejecuta en el servidor, en un contenedor aislado. Escribes NASM en el navegador, pulsas Ejecutar y Coddy ensambla y enlaza tu programa por ti. No hay nada que instalar localmente: ni NASM, ni ld, ni máquina virtual Linux.

¿Cómo leo la entrada en ensamblador aquí?

Usa la syscall read (número 0): pon 0 en rax (sys_read), 0 en rdi (stdin), la dirección de un búfer en rsi y el número máximo de bytes en rdx, y luego ejecuta syscall. Lo que escribas en el panel de stdin debajo del editor se entrega a tu programa al Ejecutar. El programa inicial muestra el patrón completo, incluido el recorte del salto de línea final.

¿Por qué mi programa necesita _start en lugar de main?

Porque el programa inicial se enlaza con ld y sin runtime de C. main es una convención de libc: el código de arranque de C lo llama después de preparar las cosas. Con un enlace ld puro no hay libc, así que el kernel salta directamente a la etiqueta _start, y por eso cada programa aquí define global _start. Eres responsable de salir limpiamente con la syscall exit (número 60) al final.

¿Puedo aprender ensamblador con este compilador incluso siendo principiante?

Sí. Empieza por el programa de saludo, cambia la cadena y observa la salida. Luego prueba a leer entrada, hacer aritmética en registros y convertir números a texto a mano. Como no hay configuración y cada Ejecución da respuesta instantánea, puedes iterar rápido, que es la forma más rápida de desarrollar intuición para los registros, la memoria y las syscalls.

Herramientas útiles para Assembly

Herramientas gratuitas basadas en el navegador que complementan el Playground de Assembly - todo parte de Coddy.

Incrusta el editor de Assembly