DEV Community: Samuel Leonardo

MAWA - El lenguaje simple en sintaxis como Python de bajo nivel. Parte 3, Condicionales.

Samuel Leonardo — Tue, 06 Jan 2026 22:03:14 +0000

Si quieren ver el canal oficial de MAWA metansé a este video, les pido que lo vean y lo compartan, aunque no da detalles sobre sintaxis, si te contextualiza de como es el lenguaje aquí en la comunidad DEV es donde muestro eso cuando el canal sea famoso ahí SI mostrare videos con la sintaxis de MAWA:

Bueno señoras y señores vuelvo con novedades de MAWA que ya sucedieron pero dije que iba a dar más detalles así que aquí volví de nuevo después de un día.

Para los que no esten contextualizados acerca de MAWA o no conozcan algunos de sus comandos pueden ver la serie de este mismo POST para ver las partes anteriores.

Las Condicionales:
Bueno para que se hagan una idea así se denomina un registro en MAWA:
En este caso estamos en Real Mode (16 BITS)

Register (AL) = 255 o 0xFF
Register (BX) = 65535 o 0xFFFF
Register (ECX) = 4,294,967,295 o 0xFFFFFFFF

He introducido hace un poco de tiempo ya en el bajo nivel las condicionales nuevas evitando el estorboso aunque no feo de igual manera proceso de comparar valores en Assembler con la funcion cmp, ya que en ASM así le dices al CPU que te compare 2 valores:

; Con el registro AL por ejemplo
cmp al, 5
je seCumplio
jne noSeCumplio

No es difícil PERO si es algo confuso para algunos ya que no se denomina, como en C++ con:

// Suponiendo que AL es un registro aunque aca sería una variable
if (al == 5) {
    // Ejecucion del If
} else {
    // Ejecucion del else
}

Aquí directamente se pone lo que se ejecuta dentro de los corchetes mientras que ASM no lo hace así sino hace calls a funciones pero MAWA ha quitado esa limitación inventada por mí mostrandonos esto:

Register (AL) = 5
Register (BL) = AL

Si: (AL == BL)
If:
    Imp ("Se cumplió")
Else:
    Imp ("No se cumplió")
End If

Llegan las condicionales permitiendonos comparar valores como registros, variables en memoria, o direcciones explicitas e incluso valores normales en un instante.

Permitiendonos usar operadores lógicos como AND o OR y también varias condiciones como el Else If para variar.

Si les gusto compartan y no se pierdan la parte 4

También estoy creando un Sistema Operativo pronto hablare bastante de él aunque en mi cuenta ya hay un post sobre él.

Sígueme si quieres más novedades de MAWA.

Samuel Leonardo Páez Garzón
6 de Enero de 2025 - Todos los derechos de autor reservados

MAWA - El lenguaje simple en sintaxis como Python de bajo nivel Parte 2, Probando mi lenguaje

Samuel Leonardo — Mon, 05 Jan 2026 21:17:43 +0000

Bueno por si no era suficiente el BOOM del Imp en MAWA (para los que no sepan de que estoy hablando vayan a este POST https://dev.to/samuel_leonardo_37aff38b4/mawa-un-lenguaje-tan-simple-como-python-pero-tan-potente-como-assembler-el-asm-moderno-pero-1ng5 y se contextualizarán del comando Imp) con la sintaxis Imp ('A') o Imp ("Hola"), etc... reduciendo mucho código, pues nunca es suficiente, ya que les traigo ACTUALIZACIONES con nueva información sobre mi lenguaje, Hola soy Samuel Leonardo Páez Garzón tengo 13 años, y este post te va a encantar en especial si te gusta el bajo nivel en la programación, o si eres OSDev, Bueno ahora si las actualizaciones.

Número 1:
Mejora Abismal del Imp

El comando Imp ya permite imprimir cadenas largas, variables y demás cosas en el lenguaje, observen:

Comando:

String (STR) = "Developer
Imp ("Hola, ", STR.0x0A, " como has estado", 0x04)

Salida:

Puedes creer que este código está hecho en 106 Bytes, asombroso MAWA tiene un sistema de funciones que le permite no reescribir rutinas para imprimir o imprimir caracter por caracter sino llamar funciones incrustadas por el compilador.

La estructura de MAWA es bastante chevre y larga para hoy el lenguaje está en un estimado de por ahí casi 7000 líneas y aproximadamente en todos sus modos unos 350 comandos en el bajo nivel tiene aprox. unos 25 o 30 comandos ya que si MAWA tiene compatibilidad con las arquitecturas, esto que significa para su comprensión:

Significa que MAWA puede usarse en Real Mode (16 BITS), Protected Mode (32 BITS) y Long Mode (64 BITS), y muy pronto tendrá un sistema para pasar a 32 BITS o 64 BITS con un solo comando, Wow, No les parece asombroso, he hecho más comandos pero por privacidad, NO los expongo por mi privacidad pero pronto expondré otros de los 25 comandos que ya hay.

Si quieren ver la estructura MAWA es así:

ARQ 16 ; Aquí declaras en que tecnología usarás MAWA
DIR 0x7C00 ; Aquí declaras donde cargas tu código para que MAWA cargue las direcciones de variables o otras cosas en esa dirección

String (Nombre) = "Samuel Leonardo Páez Garzón" ; Aquí creo una variable
Imp ("Hola ", Nombre, 0x04) ; Aquí imprimo la cadena "Hola" y la variable
InfiniteLoop() ; Esto hace un bucle infinito para no seguir avanzando en NASM sería jmp $

#Add (ALL/MWBN) ; Esto incrusta las funciones de MAWA en el archivo si está línea no está el código no te funcionara

Instruction(Rellenar-510) ; Esto rellena a 510 Bytes el archivo necesario si es un BootLoader
Insert Bytes16(0xAA55) ; Esto inserta la firma de arranque 55 AA también este comando se vale por Insert WORD(0xAA55)

https://www.youtube.com/watch?v=EnuehLUTByU

Si les gusto MAWA compartan y esperen más novedades PRONTO.

Ya publique la siguiente parte vayan y echenle un vistazo ¿No les parece?

Samuel Leonardo Páez Garzón - 5 de Enero del 2026
Todos los derechos de autor reservados

Win Anti App Anchor 1 - El Sistema Operativo del futuro desarrollado por ¿un niño de 13 años colombiano?

Samuel Leonardo — Sun, 04 Jan 2026 18:22:05 +0000

Se que el título se les hizo extraño pero es la verdad, me llamo Samuel Leonardo Páez Garzón soy Colombiano y tengo 13 años de edad y estoy desarrollando un lenguaje de programación llamado MAWA, un Sistema Operativo llamado Win Anti App Anchor y voy a comenzar a hacer una consola de videojuegos con juegos míos y un procesador de mi autoria que desafía al binario siendo diferente.

Si quieren ver información acerca de este SO estare subiendo un POST en estos días, síguanme para no perderselo.

Si quieren ver un video acerca de mi lenguaje de programación metanse en este link.

https://youtu.be/EnuehLUTByU?si=pyCs9P3dRCmZcSrg

Pronto subire un video de presentación de mi SO, sin dar detalles míos como mi cara o otras cosas por mi privacidad pero en el futuro les dare muchos más detalles en videos.

Samuel Leonardo Páez Garzón
4 de Enero del 2026 - Todos los derechos de autor reservados

MAWA - A language as simple as Python but as powerful as Assembler, modern ASM but much simpler.

Samuel Leonardo — Sun, 04 Jan 2026 03:33:10 +0000

MAWA - A programming language as simple in syntax as Python but as impressive as Assembler, it could be called Modern Assembler.

Although I have talked about MAWA before, I haven't gone into much detail. In this post, I will discuss it and explain a MAWA command, how it works, and what it does.

For those who did not read the first MAWA post, you can read it at this link: https://dev.to/samuel_leonardo_37aff38b4/mawa-el-lenguaje-de-programacion-del-futuro-2bjh My name is Samuel Leonardo Páez Garzón, I am Colombian, and I am 13.1 years old.

MAWA is a language that is simpler than others, not only in terms of syntax, but also in terms of compilation, being similar to NASM with Assembler.

An example of this is the C or C++ language in low-level mode, which uses a compiler to convert .c or .cpp to .o, then uses a linker to link to .elf, and then converts to .bin. This is quite a long process and requires many apps, whereas MAWA and Assembler work like this

ASM:
Using NASM, .asm is converted directly to .bin.

MAWA:
Using my own compiler, .mawa is converted directly to .bin.

In that respect, it's quite simple. I'll continue with the other aspect, Syntax.

While in ASM or C you have to use quite a few lines in some cases, in MAWA you don't. I'll show you.

The following codes will show everything:

In light green “0x0A”.

MAWA code:

Imp (‘A’, DefFinLinea(1), ‘B’, 0x0A)
FinalLoop (No Extensiones)
This MAWA code works as follows: in Imp, the A is printed, DefFinLinea(1) generates a line break, then B is printed, and the last argument must always be the background color and font color indicated in the last argument, which is why it is 0x0A, which in colors would be:

0 <- Background, A <- Font Color
0 is Black and A is Light Green

If this were the other way around, the letter would be black but its background would be light green.

And the second line of MAWA code leaves the code in an infinite loop that does not allow it to continue reading forward on the disk. This is done to avoid reading 00 bytes and causing QEMU to read garbage.

ASM Code NASM 16-bit sequence:

BITS 16

startCode:
mov ax, 0x0003
int 0x10

mov ah, 0x09
mov al, ‘A’
mov bl, 0x0A
mov bh, 0x00
mov cx, 1
int 0x10

call endLine

mov ah, 0x09
mov al, ‘B’
mov bl, 0x0A
mov bh, 0x00
mov cx, 1
int 0x10

jmp $

endLine:
mov ah, 0x0E
mov al, 0x0D
int 0x10

mov ah, 0x0E
mov al, 0x0A
int 0x10

ret

times 510 - ($ - $$) db 0
dw 0xAA55
This code prints A and B using 0x09 to declare color. Once the character ‘A’ has been printed, a function is called to make a line break, which automatically inserts the bytes 0x0D and 0x0A using 0x0E, creating a CR+LF line break. If you run this code, it will look exactly like the photo of QEMU that I have at the beginning of this POST.

In ASM NASM 32-bit sequence:

BITS 32

mov edi, 0xB8000
mov byte [edi], ‘A’
mov byte [edi+1], 0x0A

add edi, 160d

mov byte [edi], ‘B’
mov byte [edi+1], 0x0A

jmp $
This code loads the address of the VGA video memory located at 0xB8000 into edi, then prints the letter A in light green by inserting the values as bytes into the video memory, byte 1 being the letter and byte 2 being the color in hexadecimal binary. Then the line add edi, 160d adds 160 (80 columns * 2 bytes), which is a line break because it changes the address of edi and the letter is inserted elsewhere. Then the same process as before is performed, but with the letter B, byte 1 (which is B) and byte 2 (which is the light green color) are inserted, and then the CPU is left in an infinite loop to avoid executing garbage.

As you can see, the difference in the number of lines is huge in 16 BITS and not so much in 32 BITS, although it is more efficient in MAWA.

I am also creating another project called Win Anti App Anchor, which is an OS being created with MAWA. For those who want to know more about it, I will be uploading a post in the next few days and putting it in this post to connect them to each other.

I kindly ask you to support me by sharing this POST with many people and giving me your reactions and comments.

Samuel Leonardo Páez Garzón
November 24, 2025 - All rights reserved.
Mi Ancla CO (My future enterprise) - MAWA.

MAWA - Un lenguaje tan simple como Python pero tan potente como Assembler, el ASM moderno pero mucho más sencillo.

Samuel Leonardo — Sun, 04 Jan 2026 03:07:32 +0000

MAWA - El lenguaje de programación tan sencillo en sintaxis como Python pero tan impresionante como Assembler, podría llamarsele el Assembler Moderno.

Si quieres ver un video de MAWA metete a este link y compartelo:
https://youtu.be/EnuehLUTByU

A pesar de que ya había hablado antes acerca de MAWA, no lo había profundizado, en este post hablare de ello y expondre un comando de MAWA explicando como funciona y que realiza.

Para los que no leyeron el primer post de MAWA lo pueden leer en este link: https://dev.to/samuel_leonardo_37aff38b4/mawa-el-lenguaje-de-programacion-del-futuro-2bjh mi nombre es Samuel Leonardo Páez Garzón soy Colombiano y tengo 13.1 años.

MAWA es un lenguaje que para empezar es más simple que otros no solo en la parte de sintaxis, sino también en la de compilación, siendo igual que NASM con Assembler.

Un ejemplo de ello es el lenguaje C o C++ en modo de bajo nivel que por medio de un compilador toca hacer .c o .cpp a .o, luego con un linker enlazar a .elf, y luego pasar a .bin, esto es medio largo y requiere de muchas apps, mientras que MAWA y Assembler son así

ASM:
Por medio de NASM se hace .asm a .bin directamente.

MAWA:
Por medio de mi propio compilador se hace .mawa a .bin directamente.

En ese aspecto es bastante simple, sigo con el otro aspecto, La Sintaxis.

Mientras que en ASM o C toca usar en algunos casos bastantes líneas en MAWA NO, se los mostrare.

Los siguientes códigos mostrarán todos:

En color verde claro "0x0A".

Código MAWA:

Imp ('A', DefFinLinea(1), 'B', 0x0A)
FinalLoop (No Extensiones)

Este código MAWA funciona así, en Imp la A se imprime, DefFinLinea(1), genera un salto de línea, luego se imprime B, y el último argumento siempre debe ser el color del fondo y de la letra indicados en el último argumento, por eso esta 0x0A que en colores sería:

0 <- Fondo, A <- Color de Letra
0 es Negro y A es Verde Claro

Si esto fuera al revés la letra sería negra pero su fondo sería verde claro.

Y la segunda línea de código MAWA deja el código en un bucle infinito que no le permite seguir leyendo hacia adelante en el disco, esto se hace para evitar leer bytes 00 y hacer que QEMU lea basura.

Código ASM Secuencia NASM 16 BITS:

BITS 16

inicioCodigo:
    mov ax, 0x0003
    int 0x10

    mov ah, 0x09
    mov al, 'A'
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    call finLinea

    mov ah, 0x09
    mov al, 'B'
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    jmp $

finLinea:
    mov ah, 0x0E
    mov al, 0x0D
    int 0x10

    mov ah, 0x0E
    mov al, 0x0A
    int 0x10

    ret

times 510 - ($ - $$) db 0
dw 0xAA55

Este código imprime A y B por medio de 0x09 para declarar color, cuando ya se imprimio el caracter 'A' se llama una función para hacer salto de línea que pone automáticamente por medio de 0x0E los bytes 0x0D y 0x0A que hacen un salto de línea CR+LF, si ejecutan este código se vera exactamente igual a la fotografía de QEMU que tengo al inicio de este POST.

En ASM Secuencia NASM 32 BITS:

BITS 32

mov edi, 0xB8000
mov byte [edi], 'A'
mov byte [edi+1], 0x0A

add edi, 160d

mov byte [edi], 'B'
mov byte [edi+1], 0x0A

jmp $

Este código carga en edi la dirección de la memoria VGA de video que se encuentra en 0xB8000, luego se imprime la A con verde claro insertando los valores como bytes en la memoria de video, el byte 1 que es la letra y el byte 2 que es el color en hexadecimal binario, luego la línea add edi, 160d le añade a edi 160 (80 columnas * 2 Bytes), esto es un salto de línea, porque cambia la dirección de edi y la letra se inserta en otra parte, luego se hace el mismo proceso que antes pero con la letra B se inserta el byte 1 que es la B y el byte 2 que es el color verde claro, y luego deja la CPU en un bucle infinito para evitar ejecutar basura.

Como se dieron cuenta la diferencia en cantidad de líneas es abismal en 16 BITS y en 32 BITS no tanto aunque es más eficiente en MAWA.

También estoy creando otro proyecto llamado Win Anti App Anchor que es un SO que esta siendo creado con MAWA, los que quieran saber más acerca de él estare en estos días subiendo un post y poniendolo en este post para conectarlos mutuamente.

Les pido por favor que me apoyen compartiendo este POST a mucha gente y me regalen una reacción y comentarios.

Samuel Leonardo Páez Garzón
24 de Noviembre de 2025 - Todos los derechos de autor reservados.

Mi Ancla CO (Mi Futura Empresa) - MAWA.

MAWA - A language as simple as Python but as powerful as Assembler, modern ASM but much simpler.

Samuel Leonardo — Wed, 10 Dec 2025 18:02:06 +0000

MAWA - A programming language as simple in syntax as Python but as impressive as Assembler, it could be called Modern Assembler.

Although I have talked about MAWA before, I haven't gone into much detail. In this post, I will discuss it and explain a MAWA command, how it works, and what it does.

For those who did not read the first MAWA post, you can read it at this link: https://dev.to/samuel_leonardo_37aff38b4/mawa-el-lenguaje-de-programacion-del-futuro-2bjh My name is Samuel Leonardo Páez Garzón, I am Colombian, and I am 13.1 years old.

MAWA is a language that is simpler than others, not only in terms of syntax, but also in terms of compilation, being similar to NASM with Assembler.

An example of this is the C or C++ language in low-level mode, which uses a compiler to convert .c or .cpp to .o, then uses a linker to link to .elf, and then converts to .bin. This is quite a long process and requires many apps, whereas MAWA and Assembler work like this

ASM:
Using NASM, .asm is converted directly to .bin.

MAWA:
Using my own compiler, .mawa is converted directly to .bin.

In that respect, it's quite simple. I'll continue with the other aspect, Syntax.

While in ASM or C you have to use quite a few lines in some cases, in MAWA you don't. I'll show you.

The following codes will show everything:

In light green “0x0A”.

MAWA code:

Imp (‘A’, DefFinLinea(1), ‘B’, 0x0A)
FinalLoop (No Extensiones)

This MAWA code works as follows: in Imp, the A is printed, DefFinLinea(1) generates a line break, then B is printed, and the last argument must always be the background color and font color indicated in the last argument, which is why it is 0x0A, which in colors would be:

0 <- Background, A <- Font Color
0 is Black and A is Light Green

If this were the other way around, the letter would be black but its background would be light green.

ASM Code NASM 16-bit sequence:

BITS 16

startCode:
    mov ax, 0x0003
    int 0x10

    mov ah, 0x09
    mov al, ‘A’
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    call endLine

    mov ah, 0x09
    mov al, ‘B’
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    jmp $

endLine:
    mov ah, 0x0E
    mov al, 0x0D
    int 0x10

    mov ah, 0x0E
    mov al, 0x0A
    int 0x10

    ret

times 510 - ($ - $$) db 0
dw 0xAA55

This code prints A and B using 0x09 to declare color. Once the character ‘A’ has been printed, a function is called to make a line break, which automatically inserts the bytes 0x0D and 0x0A using 0x0E, creating a CR+LF line break. If you run this code, it will look exactly like the photo of QEMU that I have at the beginning of this POST.

In ASM NASM 32-bit sequence:

BITS 32

mov edi, 0xB8000
mov byte [edi], ‘A’
mov byte [edi+1], 0x0A

add edi, 160d

mov byte [edi], ‘B’
mov byte [edi+1], 0x0A

jmp $

This code loads the address of the VGA video memory located at 0xB8000 into edi, then prints the letter A in light green by inserting the values as bytes into the video memory, byte 1 being the letter and byte 2 being the color in hexadecimal binary. Then the line add edi, 160d adds 160 (80 columns * 2 bytes), which is a line break because it changes the address of edi and the letter is inserted elsewhere. Then the same process as before is performed, but with the letter B, byte 1 (which is B) and byte 2 (which is the light green color) are inserted, and then the CPU is left in an infinite loop to avoid executing garbage.

As you can see, the difference in the number of lines is huge in 16 BITS and not so much in 32 BITS, although it is more efficient in MAWA.

I kindly ask you to support me by sharing this POST with many people and giving me your reactions and comments.

Samuel Leonardo Páez Garzón
November 24, 2025 - All rights reserved.
Mi Ancla CO (My future enterprise) - MAWA.

MAWA - A language as simple as Python but as powerful as Assembler, modern ASM but much simpler

Samuel Leonardo — Wed, 10 Dec 2025 16:09:17 +0000

MAWA - A programming language as simple in syntax as Python but as impressive as Assembler, it could be called Modern Assembler.

Although I have talked about MAWA before, I haven't gone into much detail. In this post, I will discuss it and explain a MAWA command, how it works, and what it does.

MAWA is a language that is simpler than others, not only in terms of syntax, but also in terms of compilation, being similar to NASM with Assembler.

ASM:
Using NASM, .asm is converted directly to .bin.

MAWA:
Using my own compiler, .mawa is converted directly to .bin.

In that respect, it's quite simple. I'll continue with the other aspect, Syntax.

While in ASM or C you have to use quite a few lines in some cases, in MAWA you don't. I'll show you.

The following codes will show everything:

In light green “0x0A”.

MAWA code:

Imp (‘A’, DefFinLinea(1), ‘B’, 0x0A)
FinalLoop (No Extensiones)

0 <- Background, A <- Font Color
0 is Black and A is Light Green

If this were the other way around, the letter would be black but its background would be light green.

ASM Code NASM 16-bit sequence:

BITS 16

startCode:
    mov ax, 0x0003
    int 0x10

    mov ah, 0x09
    mov al, ‘A’
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    call endLine

    mov ah, 0x09
    mov al, ‘B’
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    jmp $

endLine:
    mov ah, 0x0E
    mov al, 0x0D
    int 0x10

    mov ah, 0x0E
    mov al, 0x0A
    int 0x10

    ret

times 510 - ($ - $$) db 0
dw 0xAA55

In ASM NASM 32-bit sequence:

BITS 32

mov edi, 0xB8000
mov byte [edi], ‘A’
mov byte [edi+1], 0x0A

add edi, 160d

mov byte [edi], ‘B’
mov byte [edi+1], 0x0A

jmp $

As you can see, the difference in the number of lines is huge in 16 BITS and not so much in 32 BITS, although it is more efficient in MAWA.

I kindly ask you to support me by sharing this POST with many people and giving me your reactions and comments.

Bueno he estado creando un lenguaje de programación desde hace ciertos tiempo quien quiera verlo métase aquí

Samuel Leonardo — Fri, 28 Nov 2025 14:07:09 +0000

MAWA💻 - Un nuevo e innovador lenguaje que estoy desarrollando prometedor, El lenguaje de programación del futuro cercano

Samuel Leonardo ・ Oct 20

#programming #beginners #showdev #codenewbie

Hello DEV community, I've been creating a programming language. If you want to know more about it, enter this post and also check out the other posts in the series, which are also about MAWA

Samuel Leonardo — Fri, 28 Nov 2025 13:47:34 +0000

MAWA💻 - The programming language of the future

Samuel Leonardo ・ Oct 20

#programming #beginners #webdev #codenewbie

MAWA No solo es lenguaje bajo nivel también es de alto nivel.

Samuel Leonardo — Thu, 27 Nov 2025 02:35:38 +0000

MAWA es de bajo nivel, pero eso es solo la punta del iceberg ya que también tiene su propio interprete de alto nivel, es capaz de generar gráficos 3D, crear apps de PC para Windows y un interprete BETA para crear páginas web y IA.

Quienes quieran saber más acerca de él he subido un post sobre dos comandos de una de sus librerías sobre el bajo nivel.

El link es: https://dev.to/samuel_leonardo_37aff38b4/mawa-un-lenguaje-tan-simple-como-python-pero-tan-potente-como-assembler-el-asm-moderno-pero-2i33

Samuel Leonardo Páez Garzón - 26 de Noviembre del 2025

Todos los derechos de autor reservados.

MAWA - A language as simple as Python but as powerful as Assembler, modern ASM but much simpler

Samuel Leonardo — Tue, 25 Nov 2025 00:19:20 +0000

MAWA - A programming language as simple in syntax as Python but as impressive as Assembler, it could be called Modern Assembler.

Although I have talked about MAWA before, I haven't gone into much detail. In this post, I will discuss it and explain a MAWA command, how it works, and what it does.

MAWA is a language that is simpler than others, not only in terms of syntax, but also in terms of compilation, being similar to NASM with Assembler.

ASM:
Using NASM, .asm is converted directly to .bin.

MAWA:
Using my own compiler, .mawa is converted directly to .bin.

In that respect, it's quite simple. I'll continue with the other aspect, Syntax.

While in ASM or C you have to use quite a few lines in some cases, in MAWA you don't. I'll show you.

The following codes will show everything:

In light green “0x0A”.

MAWA code:

Imp (‘A’, DefFinLinea(1), ‘B’, 0x0A)
FinalLoop (No Extensiones)

0 <- Background, A <- Font Color
0 is Black and A is Light Green

If this were the other way around, the letter would be black but its background would be light green.

ASM Code NASM 16-bit sequence:

BITS 16

startCode:
    mov ax, 0x0003
    int 0x10

    mov ah, 0x09
    mov al, ‘A’
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    call endLine

    mov ah, 0x09
    mov al, ‘B’
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    jmp $

endLine:
    mov ah, 0x0E
    mov al, 0x0D
    int 0x10

    mov ah, 0x0E
    mov al, 0x0A
    int 0x10

    ret

times 510 - ($ - $$) db 0
dw 0xAA55

In ASM NASM 32-bit sequence:

BITS 32

mov edi, 0xB8000
mov byte [edi], ‘A’
mov byte [edi+1], 0x0A

add edi, 160d

mov byte [edi], ‘B’
mov byte [edi+1], 0x0A

jmp $

As you can see, the difference in the number of lines is huge in 16 BITS and not so much in 32 BITS, although it is more efficient in MAWA.

I kindly ask you to support me by sharing this POST with many people and giving me your reactions and comments.

MAWA - Un lenguaje tan simple como Python pero tan potente como Assembler, el ASM moderno pero mucho más sencillo.

Samuel Leonardo — Tue, 25 Nov 2025 00:08:19 +0000

MAWA - El lenguaje de programación tan sencillo en sintaxis como Python pero tan impresionante como Assembler, podría llamarsele el Assembler Moderno.

Si quieres ver un video de MAWA metete a este link y compartelo:
https://youtu.be/EnuehLUTByU

A pesar de que ya había hablado antes acerca de MAWA, no lo había profundizado, en este post hablare de ello y expondre un comando de MAWA explicando como funciona y que realiza.

MAWA es un lenguaje que para empezar es más simple que otros no solo en la parte de sintaxis, sino también en la de compilación, siendo igual que NASM con Assembler.

ASM:
Por medio de NASM se hace .asm a .bin directamente.

MAWA:
Por medio de mi propio compilador se hace .mawa a .bin directamente.

En ese aspecto es bastante simple, sigo con el otro aspecto, La Sintaxis.

Mientras que en ASM o C toca usar en algunos casos bastantes líneas en MAWA NO, se los mostrare.

Los siguientes códigos mostrarán todos:

En color verde claro "0x0A".

Código MAWA:

Imp ('A', DefFinLinea(1), 'B', 0x0A)
FinalLoop (No Extensiones)

0 <- Fondo, A <- Color de Letra
0 es Negro y A es Verde Claro

Si esto fuera al revés la letra sería negra pero su fondo sería verde claro.

Código ASM Secuencia NASM 16 BITS:

BITS 16

inicioCodigo:
    mov ax, 0x0003
    int 0x10

    mov ah, 0x09
    mov al, 'A'
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    call finLinea

    mov ah, 0x09
    mov al, 'B'
    mov bl, 0x0A
    mov bh, 0x00
    mov cx, 1
    int 0x10

    jmp $

finLinea:
    mov ah, 0x0E
    mov al, 0x0D
    int 0x10

    mov ah, 0x0E
    mov al, 0x0A
    int 0x10

    ret

times 510 - ($ - $$) db 0
dw 0xAA55

En ASM Secuencia NASM 32 BITS:

BITS 32

mov edi, 0xB8000
mov byte [edi], 'A'
mov byte [edi+1], 0x0A

add edi, 160d

mov byte [edi], 'B'
mov byte [edi+1], 0x0A

jmp $

Como se dieron cuenta la diferencia en cantidad de líneas es abismal en 16 BITS y en 32 BITS no tanto aunque es más eficiente en MAWA.

Les pido por favor que me apoyen compartiendo este POST a mucha gente y me regalen una reacción y comentarios.

Samuel Leonardo Páez Garzón
24 de Noviembre de 2025 - Todos los derechos de autor reservados.

Mi Ancla CO (Mi Futura Empresa) - MAWA.