syscall "dllname", "functionname", [arguments...]    

    ! simple message box
    syscall "user32.dll", "MessageBoxW", 0, "Hello from BASIC!", "Title", 0
    

    ! get current user name
    x = 256
    syscall "advapi32.dll","GetUserNameW", byref a$, byref x
    print "User Name: ", a$
    

    ! launch calculator
    syscall "shell32.dll", "ShellExecuteW", 0, "open", "calc.exe", 0, 0, 1
    

    ! milliseconds since boot
    syscall "kernel32.dll","GetTickCount"
    print "Milliseconds since boot: ", V0
    

    ! RECT structure (4 DWORDs: left, top, right, bottom)
    dim rect[4].ZERO
    syscall "kernel32.dll","GetConsoleWindow"
    hwnd = V0
    syscall "user32.dll","GetWindowRect", hwnd, byref rect[]
    width = rect[2] - rect[0]
    height = rect[3] - rect[1]
    print "Width:", width, " Height:", height
    

print \
"hello"
    

print \
← empty line
"hello"
    

print \
! This is a comment
"hello"
    

print \           ! Continue to next line
                  ! <-- This empty space is now allowed in 2.4.1
"Hello world"     ! Command completes here
    

times repeatCount swap 0, 0, 80, 11, 0, 12 : title repeatCount-V3 : wait 120
    

FOR i = 0 TO repeatCount-1
swap 0, 0, 80, 11, 0, 12
title repeatCount-i
wait 120
NEXT i
    

times 10 print "Hello" : print "World" : wait 100
    

times 5 times 5 print "X:", V3;" Y:", V3
    

times 10 \
print "Hello" : \
print "World" : \
wait 100
    

times 3 print "Hello"
    

times 3 \
    print "Line 1" : \
    print "Line 2" : \
    print "Line 3"
    

times 2 \
    print "This has backslash \\ in string" : \
    print "Another with '\' quote"
    

times 4 \
    x = V3 * 10 : \
    print "Iteration ", V3, " value ", x 
    

times 5 \
    color \
    RND(15), RND(15) : \
    paint V3*5, V3*5, 5, 5, -1, 1
    

times 3 \
    print "Start" : \
    \
    print "Middle" : \
    \
    print "End"
    

times 2 \
    a = 1 : b = 2 : \
    \
    c = a + b : \
    \
    print "Sum = ", c : \
    \
    wait 100
    

times 3 print "Test"\
    : print "Continued"
    

times 3 \

    ! Comment \

    print "Hello" : \

    print "World"
    

times 0 \
    print "This should not print"
print "Skipped"
    

print "Nested TIMES test:"
times 2 \
    print "Outer ", V3, ":" : \
    times 3 \
        print "  Inner ", V3
inkey
    

for \
    outer = 1 \
    to 3 \
    
    print "┌─ OUTER ITERATION ", outer, " ───────────────────────┐" : \
    
    for \
        middle = 1 \
        to 4 \
        
        print "│  Middle: ", middle, " " : \
        
        times \
            2 \
            
            print "│    Times[", V3, "] " : \
            
            if \
                V3 = 0 \
                then \
                    print "First " : \
                else \
                    print "Second" : \

        print "│"
        
    next \
    middle : \
    
    print "└──────────────────────────────────────────────┘" : \
    print  ! Blank line
    
next \
outer
    

forever#
dim data[5,5].RND 10000
data[].SIZE
array_length = V0
  
times array_length : \
    sum = 0 : \

    times 5 \
        value = data[V3,V3] : \
        sum = sum + value : \
        average = sum / 5 : \
        print "row ", V3, " average: ", average

goto forever
    

!  Some methods return a value, which is stored in V0.
!  These are: COUNT, FIND, MATCH, SIZE, SUM, MIN, MAX, FILE, and COMPARE.
!  Other methods perform an in-place operation and do not return a value.

        ! STRING ARRAYS (Strings only)
        !  a$[].FILE dpath$        - List dir content
        !  a$[].FILE fpath$        - Read file lines
        !  a$[].SORT               - Sort array alphabetically

        ! STRING/INTEGER ARRAYS (Both types)
        !  a$[].ZERO               - Fill with zeros/empty strings
        !  a$[].SHUFFLE            - Shuffle array elements
        !  a$[].REVERSE            - Reverse element order
        !  a$[].COPY b$[]          - Copy b[] into a[]
        !  a$[].SWAP b$[]          - Swap contents with b[]
        !  a$[].DELETE idx [, ...] - Delete elements by index
        !  a$[].INSERT idx, v [...] - Insert values at index
        !  a$[].FIND x             - Find first index of value
        !  a$[].SIZE               - Return array dimensions
        !  a$[].OUT [indent]       - Print full array

        ! INTEGER ARRAYS (Integers only)
        !  a[].FILL value          - Fill with a value
        !  a[].RND max             - Fill with random values
        !  a[].SET start           - Fill with consecutive values
        !  a[].COUNT x             - Count occurrences
        !  a[].SUM                 - Sum of array values
        !  a[].MIN                 - Minimum array element (0 if empty)
        !  a[].MAX                 - Maximum array element (0 if empty)
        !  a[].MATCH x [...]       - 1 if match found, else 0
        !  a[].REPLACE a, b        - Replace a with b
        !  a[].ASSIGN b[] x [...]  - Store matches from b[]
        !  a[].COMPARE b[]         - Compare with b[]
        !  a[].SORTA               - Sort ascending
        !  a[].SORTD               - Sort descending
    

! BEFORE: Indirectly with variables
a[].SUM
if V0 > 100 then print "Large total"

! AFTER: Directly in expression
if a[].SUM > 100 then print "Large total"

! NEW: MIN and MAX
print "Range:", a[].MAX - a[].MIN
    

! BEFORE: Multiple intermediate variables
data[].SUM
sum = V0
data[].MAX
max = V0
if sum > 50 and max < 20 then print "OK"

! AFTER: All in one line
if data[].SUM > 50 and data[].MAX < 20 then print "OK"

! NEW: In SELECT CASE
select case values[].MIN
    case < 0: print "Contains negatives"
    case > 100: print "All above 100"
endsel
    

! BEFORE: Two steps
dim lines$[1000]
lines$[].FILE path$
count = SIZE(lines$[]) - 1

! AFTER: One command
count = lines$[].FILE path$  ! returns the line count

if count > 0 then print "Lines: ", count
    

! BEFORE: Via function
COMPARE(a[], b[])
result = V0
if result = 1 then print "Equal"

! AFTER: Directly as condition
if a[].COMPARE b[] then print "Arrays are identical"

! NEW: Combinations
if a[].COMPARE b[] and a[].MAX < 100 then print "Valid"
    

! Finding value range
dim temps[7] = 15, 22, 18, 25, 20, 16, 24
range = temps[].MAX - temps[].MIN  ! 25 - 15 = 10

! Boundary checking
if temps[].MAX > 30 then print "Heat warning!"
if temps[].MIN < 10 then print "Cold warning!"

! With empty array they return 0
dim empty[]
print empty[].MIN  ! 0
print empty[].MAX  ! 0
    

! Hobby BASIC: Peak expressiveness

push -1,-2,-3               ! stack values
dim data[] = RND()%100, \      ! array with random init
            RND()%100, POW(2,8)

sub stats(arr[])               ! user subroutine
    syscall "kernel32","GetTickCount"  ! Windows API call
    debug("Ticks:",V0," Min:",arr[].MIN," Max:",arr[].MAX)
    rets arr[].SUM>100         ! array method in return
ends

if stats(data[])               ! subroutine as condition
    dim a[3] : a[].COPY stack[]   ! copy stack to regular array
    dim words$[] = "Alpha","Beta","Gamma"  ! string array
    color 12,0 : debug("SUM="+STR(data[].SUM)," Stack:",stack[V3])
    a[].REVERSE               ! reverse integer array
    words$[].REVERSE          ! reverse string array
    ! FPU string math: calculate average with floating point
    debug("Avg:",FDIV(STR(data[].SUM), STR(SIZE(data[]))))
    times 3 : debug(a[V3], "=", words$[V3]) ! parallel iteration
    inkey ! wait for any key press
endif