; n+(((p-1)-(n+p-1))&(p-1))

function align.n, n, p
 . r1=p, r1-1, r2=n, r2+r1, r0=r1,\
 r0-r2, r0&r1, r1=r0, r2=n, r0+r2
endf  

macro set.nibble v, i, n { ; v|=(n<<(i*4))
 . r0=v, r1=i, r2=n, r1<<2, r2<<cl,\
 r0|r2, v=r0
}     

function triplet, a, b, c
 . r0=a, r0<<6, r1=b, r1<<3, r0|r1, r0|c
endf 

function rgb, r, g, b
 . r0=r, r0<<16, r1=g, r1<<8,\
 r0|r1, r2=b, r0|r2
endf  

; standard copy with 0 after

function text.copy, a, b
 . r0=a, r2=b
 while byte [r2]
  . cl=[r2], [r0]=cl,\
  r0++, r2++
 endw
 . byte [r0]=0
endf  

; attach b to a

function text.attach, a, b
 text.n a
 . r0+a
 text.copy r0, b
endf

; search 32BIT integer array for v.
; return address or 0

function search.n, a, v, n
 . r0=a, r1=v
 repeat n
  if [r0]=r1
   return
  end
  . r0+4
 endr
endf 0

; shuffle all array indices in a unique
; fashion with no duplicates

function array.randomize, a
 locals i, j, n, s, max, p
 . r0=a, s=[?array.s+r0],\
  n=[?array.n+r0], r1=n,\
  r1--, max=r1
 try p=allocate s
 loop i=0 to n
  get j=random max
  array.exchange a, i, j, p
 endl
 destroy p
endf

; 24/32 must be copied backwards because
; of overlap...

function convert.pixels.24.32, p, n
 locals i
 . r0=p, r2=r0, r1=n,\
  r0=&[r0+r1*4-4], r1*3, r1-3, r2+r1
 loop i=0 to n
  . r1=[r2], r1&0FFFFFFh, r1<<8,\
  [r0]=r1, r2-3, r0-4
 endl
endf  

; rotate 'r'ight (90) or 'l'eft (270)

function rotate.image, image, way
 locals x, y, w, h, p, s, col, row
 . r0=image, s=[?image.p+r0],\
  w=[?image.w+r0], h=[?image.h+r0]
 try p=scratch h, w ; w/h reversed
 if way='r'         ; right, 90
  . r0=h,\
   r0--, col=r0
  loop y=0 to h
   loop x=0 to w
    . r0=x, r0*h, r0+col, r0<<2,\
     r0+p, r2=y, r2*w, r2+x, r2<<2,\
    r2+s, [r0]=[r2]
   endl
   . col--
  endl
 else.if way='l' ; left, 270
  . col=0
  loop y=0 to h
   . r0=w, r0--, row=r0
   loop x=0 to w
    . r0=row, r0*h, r0+col, r0<<2,\
     r0+p, r2=y, r2*w, r2+x, r2<<2,\
    r2+s, [r0]=[r2], row--
   endl
   . col++
  endl
 end
 end.scratch image
 . r0=image,\ ; adjust location
  r2=[?image.x+r0], r1=w, r1>>1, r2+r1,\
  r1=h, r1>>1, r2-r1, [?image.x+r0]=r2,\
  r2=[?image.y+r0], r1=h, r1>>1, r2+r1,\
  r1=w, r1>>1, r2-r1, [?image.y+r0]=r2
endf     

; size by percentage (integer)

function size.image.p, image, p
 locals w, h, iw, ih
 . r0=image,\
  iw=[?image.w+r0], ih=[?image.h+r0],\
  r0=iw, r0*p, r1=100, r0/r1, w=r0,\
  r0=ih, r0*p, r1=100, r0/r1, h=r0
 size.image image, w, h
endf   

function mix, a, b, n
 locals sr, sg, sb, dr, dg, db
 . r0=a, r2=b

 . \ ; extract r/g/b components
  r1=r0, r1>>16, r1&0FFh, sr=r1,\
  r1=r0, r1>>8, r1&0FFh, sg=r1,\
  r1=r0, r1&0FFh, sb=r1,\
  r1=r2, r1>>16, r1&0FFh, dr=r1,\
  r1=r2, r1>>8, r1&0FFh, dg=r1,\
  r1=r2, r1&0FFh, db=r1

 . \ ; calculate deltas: (((s-d)*a)/256)+d
  r0=sr, r0-dr, r0*n, r0>>8, r0+dr,\
  r1=sg, r1-dg, r1*n, r1>>8, r1+dg,\
  r2=sb, r2-db, r2*n, r2>>8, r2+db

 . \ ; construct RGB
  r0<<16, r1<<8, r0|r1, r0|r2
endf 

; draw 32BPP scanline with alpha (AA.RR.GG.BBh).

; * 0     - 100% visible/opaque
; * 1-254 - transparent
; * 255   - 100% invisible (a&0FF000000h=0)

function draw.scanline.a, pixels, x, y, w
 locals i
 push r6 r7
 . r0=&i, r6=&x, r7=&y, r1=&w
 clip.scanline r0, r6, r7, r1
 fail .e
 vga.xy [r6], [r7]
 . r7=r0, r6=pixels, r6+i

 repeat w           ; draw pixels
  . r0=[r6]         ; get pixel
  if r0&0FF000000h  ; alpha?
   . r1=r0, r1>>>24
   if r1=0FFh       ; invisible
    jmp .next
   end
   mix [r7], r0, r1 ; result in r0
  end
  . [r7]=r0         ; *vga++=*p++
  .next:
  . r6+4, r7+4
 endr
 .e:
 pop r7 r6
endf

function load.file, file
 fault .0
 try open file
 try [file.p]=allocate [file.n]
 try read [file.p], [file.n]
 close
 . r1=[file.n]
 return [file.p]
 .0: flush
 close
endf 0

function save.file, file, p, n
 fault .0
 try create file
 try write p, n
 close
 return 1
 .0: close
endf 0

function load.text, file
 fault .0
 try open file
 . r0=[file.n], r0++
 try [file.p]=allocate r0
 try read [file.p], [file.n]
 close
 . r0=[file.p],\
  r1=[file.n], byte [r0+r1]=0
 escape
 .0: flush
 close
endf 0

function save.text, file, t
 text.n t
 save.file file, t, r0
endf

function append.file, file, p, n
 fault .0
 !if open, file
  seek.r 0, SEEK_END
 else
  try create file
 end
 try write p, n
 close
 return file
 .0: close
endf 0    

A lot of the syntax you use reminds me of C and the examples one sees with C code. Short generic function names. Short generic variable names. Dense coding that requires horizontal scanning. Little or no error checking. Lots of dots and other types of non-alphanumeric characters.

include 'z.inc'

text title='My Window', wc.name='W1'

HANDLE module, window
MSG msg
WNDCLASSEX wc

;;;;;;;;;;;;;;;;;;;;;; MAIN ;;;;;;;;;;;;;;;;;;;;;

function main
 locals x, y, w, h

 get [module]=GetModuleHandleA 0

 . [wc.cbSize]=WNDCLASSEX.$
 . [wc.lpfnWndProc]=!window.procedure
 . [wc.hInstance]=[module]
 . [wc.lpszClassName]=wc.name
 . [wc.style]=CS_DBLCLKS
 . [wc.hbrBackground]=8

 get [wc.hIcon]=LoadIconA 0, 7F00h
 get [wc.hCursor]=LoadCursorA 0, 7F00h

 try RegisterClassExA wc

 . w=720, h=480
 . r0=[os.w], r0>>1         ; x=sw/2-w/2
 . r2=w, r2>>1, r0-r2, x=r0
 . r0=[os.h], r0>>1         ; y=sh/2-h/2
 . r2=h, r2>>1, r0-r2, y=r0

 try [window]=CreateWindowExA 0, wc.name,\
  title, WS_DEFAULT, x, y, w, h,\
  0, 0, [module], 0

 @@:
  GetMessageA msg, 0, 0, 0
  fail .r
  TranslateMessage msg
  DispatchMessageA msg
 jmp @b
 .r:
endf [msg.wParam]

;;;;;;;;;;;;;;;; WINDOW PROCEDURE ;;;;;;;;;;;;;;;;

function window.procedure, w, message, wp, lp

 if message=WM_KEYDOWN
  say 'Key Press'

 else.if message=WM_LBUTTONDOWN
  say 'Mouse Click'

 else.if message=WM_CLOSE
  PostQuitMessage 0
  return 1
 end

 DefWindowProcA w, message, wp, lp
endf    

I must admit your language kinda look confusing

get c=rgb 7Fh, 0, 7Fh    

try create file
try p=allocate 4*KB    

fault .0 ; try will jmp to .0 if error    

When is [] needed?

It takes a long time to learn.

function main
 create f     ; create file
 write s, n   ; write to current file
 close        ; close after create
 open f       ; reopen
 read t, n    ; read to t
 say t        ; display text
 close        ; close after open
 execute f    ; execute maximize
endf    

try p=allocate 4*KB
try open name
read p, 4*KB
close    

try p=load.file name ; or entire file    

FILE *fp;
char *p;

if (!(p=(char*)malloc(4096))) {
  return 0;
}
if (!(fp=fopen(name, "rb"))) {
  return 0;
}
fread(p, 1, 4096, fp);
fclose(fp);    

invoke HeapAlloc, [_heap], 0, 4096
mov [p], eax
test eax, eax
jz .r
invoke CreateFileA, name, GENERIC_READ \
 or GENERIC_WRITE, FILE_SHARE_READ, 0, \
 OPEN_EXISTING, 0, 0
mov [fp], eax
cmp eax, -1
je .r
invoke ReadFile, [fp], [p], 4096, tmp.rw, 0
invoke CloseHandle, [fp]    

call allocate, 4096
mov [p], r0
test r0, r0
jz .r
call open, name
mov [fp], r0
cmp r0, -1
je .r
call read, [p], 4096
call close    

; Z: 1 line...

integer x, y, w, h, i, j, n, p, q, s    

; Standard: 10 lines, 10 times as much code!

x dd 0
y dd 0
w dd 0
h dd 0
i dd 0
j dd 0
n dd 0
p dd 0
q dd 0
s dd 0    

; Z: 4 lines

structure IMAGE
 void p
 integer x, y, w, h, bpp, key, alpha
ends ?image    

; Standard: 21 lines, 5+ times as much code...

struct IMAGE
 p dd 0
 x dd 0
 y dd 0
 w dd 0
 h dd 0
 bpp dd 0
 key dd 0
 alpha dd 0
ends

virtual at 0
?image:
 .p dd 0
 .x dd 0
 .y dd 0
 .w dd 0
 .h dd 0
 .bpp dd 0
 .key dd 0
 .alpha dd 0
end virtual