Datasets:

EkBass
/

BazzBasic_AI_Guide

@@ -1,603 +0,0 @@
----
-name: bazzbasic
-description: "BazzBasic BASIC interpreter language reference. Use when writing, debugging, or explaining BazzBasic code (.bas files). Triggers on: BazzBasic syntax, $ and # variable suffixes, SDL2 graphics in BASIC, SCREEN/DRAWSHAPE/LOADIMAGE commands, DEF FN functions, BazzBasic file I/O, sound commands, or any question about BazzBasic features. Always use this skill before writing any BazzBasic code."
----
-# BazzBasic Language Reference
-**Version:** 1.3b | **Author:** Kristian Virtanen (EkBass) | **Platform:** Windows x64
-**GitHub:** https://github.com/EkBass/BazzBasic
-**Manual:** https://ekbass.github.io/BazzBasic/manual/#/
-**Examples:** https://github.com/EkBass/BazzBasic/tree/main/Examples
-**Rosetta Code:** https://rosettacode.org/wiki/Category:BazzBasic
----
-## ⚠️ Critical Rules — Read First
-| Rule | Detail |
-|------|--------|
-| Variables end with `$` | `name$`, `score$`, `x$` |
-| Constants end with `#` | `MAX#`, `PI#`, `TITLE#` |
-| Arrays declared with `DIM`, end with `$` | `DIM items$` |
-| First use of variable requires `LET` | `LET x$ = 0` — after that `x$ = x$ + 1` |
-| FOR and INPUT auto-declare, no LET needed | `FOR i$ = 1 TO 10` |
-| Functions defined **before** they are called | Put at top or INCLUDE |
-| Function name ends with `$`, called with `FN` | `FN MyFunc$(a$, b$)` |
-| Function return value **must** be used | `PRINT FN f$()` or `LET v$ = FN f$()` |
-| Arrays **cannot** be passed to functions directly | Pass individual elements, or serialize to JSON string — see *Passing Arrays to Functions* section |
-| Case-insensitive | `PRINT`, `print`, `Print` all work |
-| `+` operator does both add and concatenate | `"Hi" + " " + name$` |
-| Division always returns float | `10 / 3` → `3.333...` |
----
-## ABOUT
-BazzBasic is built around one simple idea: starting programming should feel nice and even fun.
-Ease of learning, comfort of exploration and small but important moments of success.
-Just like the classic BASICs of decades past, but with a fresh and modern feel.
-## STORY
-Although over the years, as my own skills have grown, I have moved on to more versatile and modern languages, BASIC has always been something that has been fun to try out many different things with.
-Sometimes it's great to just make a simple adventure game again, a lottery machine, a quiz, or even just those balls bouncing on the screen.
-BazzBasic was created with this in mind.
-I wanted to create a language that makes it easy for you to give free rein to your curiosity and program something.
-And when you finish your first little game, you may crave something bigger and better.
-Maybe one day you will move on to another programming language, but then BazzBasic will have succeeded in doing what it was intended for.
-To arouse your curiosity.
-## Variables & Constants
-```basic
-LET a$                      ' Declare without value
-LET name$ = "Alice"         ' String variable
-LET score$ = 0              ' Numeric variable
-LET x$, y$, z$ = 10        ' Multiple declaration
-LET PI# = 3.14159           ' Constant (immutable)
-LET TITLE# = "My Game"      ' String constant
-```
-**Compound assignment operators** (variables only — **not** allowed with `#` constants):
-```basic
-x$ += 5     ' add
-x$ -= 3     ' subtract
-x$ *= 2     ' multiply
-x$ /= 4     ' divide
-s$ += " World"  ' string concatenation
-```
-**Scope:** All main-code variables share one scope (even inside IF blocks).
-`DEF FN` functions are fully isolated — only global constants (`#`) accessible inside.
-**Comparison:** `"123" = 123` is TRUE (cross-type), but keep types consistent for speed.
-### Built-in Constants
-- **Boolean:** `TRUE`, `FALSE`
-- **Math:** `PI#`, `HPI#` (π/2 = 90°), `QPI#` (π/4 = 45°), `TAU#` (2π = 360°), `EULER#` (e) — `#` suffix required
-- **System:** `PRG_ROOT#` (program base directory path)
-- **Keyboard:** `KEY_ESC#`, `KEY_ENTER#`, `KEY_SPACE#`, `KEY_UP#`, `KEY_DOWN#`, `KEY_LEFT#`, `KEY_RIGHT#`, `KEY_F1#`…`KEY_F12#`, `KEY_A#`…`KEY_Z#`, `KEY_0#`…`KEY_9#`, `KEY_LSHIFT#`, `KEY_LCTRL#`, etc.
----
-## Arrays
-```basic
-DIM scores$                         ' Declare (required before use)
-DIM a$, b$, c$                      ' Multiple
-scores$(0) = 95                     ' Numeric index (0-based)
-scores$("name") = "Alice"           ' String key (associative)
-matrix$(0, 1) = "A2"                ' Multi-dimensional
-```
-| Function/Command | Description |
-|-----------------|-------------|
-| `LEN(arr$())` | Total element count (note empty parens) |
-| `ROWCOUNT(arr$())` | Count of first-dimension rows — use this for FOR loops over multi-dim arrays |
-| `HASKEY(arr$(key))` | 1 if exists, 0 if not |
-| `DELKEY arr$(key)` | Remove one element |
-| `DELARRAY arr$` | Remove entire array (can re-DIM after) |
-| `JOIN dest$, src1$, src2$` | Merge two arrays; `src2$` keys overwrite `src1$`. Use empty `src1$` as `COPYARRAY`. |
-**Always check with `HASKEY` before reading uninitialized elements.**
----
-## Control Flow
-```basic
-' Block IF
-IF score$ >= 90 THEN
-    PRINT "A"
-ELSEIF score$ >= 80 THEN
-    PRINT "B"
-ELSE
-    PRINT "F"
-END IF                      ' ENDIF also works
-' One-line IF (GOTO/GOSUB only)
-IF lives$ = 0 THEN GOTO [game_over]
-IF key$ = KEY_ESC# THEN GOTO [menu] ELSE GOTO [play]
-' FOR (auto-declares variable)
-FOR i$ = 1 TO 10 STEP 2 : PRINT i$ : NEXT
-FOR i$ = 10 TO 1 STEP -1 : PRINT i$ : NEXT
-' WHILE
-WHILE x$ < 100 : x$ = x$ * 2 : WEND
-' Labels, GOTO, GOSUB
-[start]
-    GOSUB [sub:init]
-    GOTO [main]
-[sub:init]
-    LET x$ = 0
-RETURN
-' Dynamic jump (variable must contain "[label]" with brackets)
-LET target$ = "[menu]"
-GOTO target$
-' Other
-SLEEP 2000                  ' Pause ms
-END                         ' Terminate program
-```
----
-## I/O
-| Command | Description |
-|---------|-------------|
-| `PRINT expr; expr` | `;` = no space, `,` = tab |
-| `PRINT "text";` | Trailing `;` suppresses newline |
-| `INPUT "prompt", var$` | Splits on whitespace/comma |
-| `INPUT "prompt", a$, b$` | Multiple values |
-| `LINE INPUT "prompt", var$` | Read entire line with spaces |
-| `CLS` | Clear screen |
-| `LOCATE row, col` | Move cursor (1-based) |
-| `CURPOS("row")` / `CURPOS("col")` | Read cursor row or col (1-based, matches LOCATE) |
-| `CURPOS()` | Read cursor as `"row,col"` string |
-| `COLOR fg, bg` | Text colors (0–15 palette) |
-| `SHELL("cmd")` | Run shell command, returns output |
-| `SHELL("cmd", ms)` | With timeout in ms (default 5000) |
-**Escape sequences in strings:** `\"` `\n` `\t` `\\`
-### Keyboard Input
-| Function | Returns | Notes |
-|----------|---------|-------|
-| `INKEY` | Key value or 0 | Non-blocking |
-| `KEYDOWN(key#)` | TRUE/FALSE | Held-key detection; **graphics mode only** |
-| `WAITKEY(key#, ...)` | Key value | Blocks until key pressed; `WAITKEY()` = any key |
-### Mouse (graphics mode only)
-`MOUSEX`, `MOUSEY` — cursor position
-`MOUSELEFT` - `MOUSERIGHT`, `MOUSEMIDDLE` — 1 if pressed, 0 otherwise
-`MOUSEHIDE` — hide the mouse cursor (graphics screen only)
-`MOUSESHOW` — restore the mouse cursor (graphics screen only)
-### Console Read
-`GETCONSOLE(row, col, type)` — type: 0=char (ASCII), 1=fg color, 2=bg color
----
-## User-Defined Functions
-```basic
-' Define BEFORE calling. Name must end with $.
-DEF FN Clamp$(val$, lo$, hi$)
-    IF val$ < lo$ THEN RETURN lo$
-    IF val$ > hi$ THEN RETURN hi$
-    RETURN val$
-END DEF
-PRINT FN Clamp$(5, 1, 10)          ' ✓ OK — return value used
-LET v$ = FN Clamp$(15, 0, 10)     ' ✓ OK
-FN Clamp$(5, 1, 10)                ' ✗ ERROR — return value unused
-```
-- Isolated scope: no access to global variables, only global constants (`#`)
-- Parameters passed **by value**
-- Labels inside functions are local — GOTO/GOSUB cannot jump outside
-- Supports recursion
-- Arrays as parameters not allowed. Use ASJSON to make array as JSON-string to pass it.
-- Use `INCLUDE` to load functions from separate files if many
----
-## String Functions
-| Function | Description |
-|----------|-------------|
-| `ASC(s$)` | ASCII code of first char |
-| `CHR(n)` | Character from ASCII code |
-| `INSTR(s$, search$)` | Position (1-based), 0=not found; case-sensitive by default |
-| `INSTR(s$, search$, mode)` | mode: 0=case-insensitive, 1=case-sensitive |
-| `INSTR(start, s$, search$)` | Search from position (case-sensitive) |
-| `INVERT(s$)` | Reverse string |
-| `LCASE(s$)` / `UCASE(s$)` | Lower / upper case |
-| `LEFT(s$, n)` / `RIGHT(s$, n)` | First/last n chars |
-| `LEN(s$)` | String length |
-| `LTRIM(s$)` / `RTRIM(s$)` / `TRIM(s$)` | Strip whitespace |
-| `MID(s$, start)` | Substring from start (1-based) |
-| `MID(s$, start, len)` | Substring with length |
-| `REPEAT(s$, n)` | Repeat string n times |
-| `REPLACE(s$, a$, b$)` | Replace a$ with b$ in s$ |
-| `SPLIT(arr$, s$, sep$)` | Split into array, returns count |
-| `SRAND(n)` | Random alphanumeric string of length n |
-| `STR(n)` | Number to string |
-| `VAL(s$)` | String to number |
-| `SHA256(s$)` | SHA256 hash (64-char hex) |
-| `BASE64ENCODE(s$)` / `BASE64DECODE(s$)` | Base64 encode/decode |
----
-## Math Functions
-| Function | Description |
-|----------|-------------|
-| `ABS(n)` | Absolute value |
-| `ATAN(n)` | Arc tangent |
-| `BETWEEN(n, min, max)` | TRUE if min ≤ n ≤ max |
-| 'INBETWEEN(n, min, max)' |TRUE if min < n < max (strictly between, not equal) |
-| `CEIL(n)` / `FLOOR(n)` | Round up / down |
-| `CINT(n)` | Round to nearest integer |
-| `CLAMP(n, min, max)` | Constrain n to [min, max] |
-| `COS(n)` / `SIN(n)` / `TAN(n)` | Trig (radians) |
-| `DEG(rad)` / `RAD(deg)` | Radians ↔ degrees |
-| `DISTANCE(x1,y1, x2,y2)` | 2D Euclidean distance |
-| `DISTANCE(x1,y1,z1, x2,y2,z2)` | 3D Euclidean distance |
-| `EXP(n)` | e^n |
-| `INT(n)` | Truncate toward zero |
-| `LERP(start, end, t)` | Linear interpolation (t: 0.0–1.0) |
-| `LOG(n)` | Natural logarithm |
-| `MAX(a, b)` / `MIN(a, b)` | Larger / smaller of two |
-| `MOD(a, b)` | Remainder |
-| `POW(base, exp)` | Power |
-| `RND(n)` | Random integer 0 to n-1 |
-| `ROUND(n)` | Standard rounding |
-| `SGN(n)` | Sign: -1, 0, or 1 |
-| `SQR(n)` | Square root |
-**Math constants:** `PI#`, `HPI#` (PI/2), `QPI#` (PI/4), `TAU#` (PI*2), `EULER#`
----
-## Graphics
-```basic
-SCREEN 12                           ' 640×480 VGA (recommended)
-SCREEN 0, 800, 600                  ' Custom size
-SCREEN 0, 1024, 768, "My Game"      ' Custom size + title
-FULLSCREEN TRUE                     ' Borderless fullscreen (graphics only)
-FULLSCREEN FALSE                    ' Windowed
-```
-| Mode | Resolution |
-|------|-----------|
-| 1 | 320×200 |
-| 2 | 640×350 |
-| 7 | 320×200 |
-| 9 | 640×350 |
-| 12 | 640×480 ← recommended |
-| 13 | 320×200 |
-### Drawing Primitives
-```basic
-PSET (x, y), color                          ' Pixel
-LINE (x1,y1)-(x2,y2), color                ' Line
-LINE (x1,y1)-(x2,y2), color, B             ' Box outline
-LINE (x1,y1)-(x2,y2), color, BF            ' Box filled (FAST — use instead of CLS)
-CIRCLE (cx,cy), radius, color              ' Circle outline
-CIRCLE (cx,cy), radius, color, 1           ' Circle filled
-PAINT (x, y), fillColor, borderColor       ' Flood fill
-LET c$ = POINT(x, y)                       ' Read pixel color
-LET col$ = RGB(r, g, b)                    ' Create color (0–255 each)
-```
-**Color palette (COLOR command, 0–15):** 0=Black, 1=Blue, 2=Green, 3=Cyan, 4=Red, 5=Magenta, 6=Brown, 7=Lt Gray, 8=Dk Gray, 9=Lt Blue, 10=Lt Green, 11=Lt Cyan, 12=Lt Red, 13=Lt Magenta, 14=Yellow, 15=White
-### Screen Control
-```basic
-SCREENLOCK ON                       ' Buffer drawing (start frame)
-SCREENLOCK OFF                      ' Present buffer (end frame)
-VSYNC(TRUE)                         ' Enable VSync (default, ~60 FPS)
-VSYNC(FALSE)                        ' Disable VSync (benchmarking)
-CLS                                 ' Clear screen (slow — prefer LINE BF)
-```
-### Shapes & Images
-```basic
-' Create shape
-' LOADSHAPE and LOADIMAGE return a stable integer handle — never reassigned.
-' SDL2 owns the resource; your code only ever holds this one reference. Use constants.
-LET RECT# = LOADSHAPE("RECTANGLE", w, h, color)  ' or "CIRCLE", "TRIANGLE"
-LET IMG_PLAYER# = LOADIMAGE("player.png")         ' PNG (alpha) or BMP
-LET IMG_REMOTE# = LOADIMAGE("https://example.com/a.png") ' Download + load
-' Sprite sheet — sprites indexed 1-based
-DIM sprites$
-LOADSHEET sprites$, 128, 128, "sheet.png"        ' tileW, tileH, file
-MOVESHAPE sprites$(1), x, y                      ' sprites$(1) = first sprite
-' Transform
-MOVESHAPE RECT#, x, y               ' Position by center point
-ROTATESHAPE RECT#, angle            ' Degrees (absolute)
-SCALESHAPE RECT#, scale             ' 1.0 = original size
-DRAWSHAPE RECT#                     ' Render to buffer
-SHOWSHAPE RECT# / HIDESHAPE RECT#   ' Toggle visibility
-REMOVESHAPE RECT#                   ' Free memory (always clean up)
-```
----
-### Text Rendering (SDL2_ttf.dll required)
-#### DRAWSTRING & LOADFONT
-```basic
-' Default font (Arial)
-DRAWSTRING "Hello!", 100, 200, RGB(255, 255, 255)
-' Load alternative font — becomes the new default
-LOADFONT "comic.ttf", 24
-DRAWSTRING "Hello!", 100, 200, RGB(255, 255, 255)
-' Reset to Arial
-LOADFONT
-```
-`DRAWSTRING x, y` positions the top-left of the text. Requires `SDL2_ttf.dll` in the same directory as the interpreter. Prefer this over PRINT, which makes graphic screen easily blinking.
----
-## Sound
-```basic
-' LOADSOUND returns a stable integer handle — SDL2 manages the resource.
-' The handle never changes; store it in a constant to protect it from accidental reassignment.
-LET SND_JUMP# = LOADSOUND("jump.wav")   ' Load (WAV recommended)
-SOUNDONCE(SND_JUMP#)                    ' Play once, non-blocking
-SOUNDONCEWAIT(SND_JUMP#)               ' Play once, wait for finish
-SOUNDREPEAT(SND_JUMP#)                 ' Loop continuously
-SOUNDSTOP(SND_JUMP#)                   ' Stop specific sound
-SOUNDSTOPALL                            ' Stop all sounds
-```
-Load all sounds at startup. Call `SOUNDSTOPALL` before `END`.
----
-## File I/O
-```basic
-LET data$ = FileRead("file.txt")        ' Read as string
-DIM cfg$ : LET cfg$ = FileRead("settings.txt")  ' Read as key=value array
-FileWrite "save.txt", data$             ' Create/overwrite
-FileAppend "log.txt", entry$            ' Append
-LET ok$ = FileExists("file.txt")        ' 1=exists, 0=not
-FileDelete "temp.dat"                   ' Delete file
-```
-**key=value parsing:** When `FileRead` assigns to a `DIM`'d array, lines `key=value` become `arr$("key")`. Lines starting with `#` are comments. Perfect for `.env` files.
-```basic
-DIM env$
-LET env$ = FileRead(".env")
-LET API_KEY# = env$("OPENAI_API_KEY")
-```
-**Paths:** Use `/` or `\\` — never single `\` (it's an escape char). Relative paths are from `PRG_ROOT#`.
-**FileWrite with array** saves in key=value format (round-trips with FileRead).
----
-## Network
-```basic
-LET res$ = HTTPGET("https://api.example.com/data")
-LET res$ = HTTPPOST("https://api.example.com/submit", "{""key"":""val""}")
-' With headers (optional last parameter)
-DIM headers$
-headers$("Authorization") = "Bearer mytoken"
-headers$("Content-Type") = "application/json"
-LET res$ = HTTPGET("https://api.example.com/data", headers$)
-LET res$ = HTTPPOST("https://api.example.com/data", body$, headers$)
-```
----
-## Arrays & JSON
-Nested JSON maps to comma-separated keys: `data$("player,name")`, `data$("skills,0")`
-```basic
-' Array → JSON string
-LET json$ = ASJSON(arr$)
-' JSON string → array (returns element count)
-DIM data$
-LET count$ = ASARRAY(data$, json$)
-' Load/save JSON files
-LOADJSON arr$, "file.json"
-SAVEJSON arr$, "file.json"
-```
----
-## Fast Trigonometry
-~20× faster than `SIN(RAD(x))`, 1-degree precision. Uses ~5.6 KB memory.
-```basic
-FastTrig(TRUE)                      ' Enable lookup tables (must call first)
-LET x$ = FastCos(45)               ' Degrees, auto-normalized 0–359
-LET y$ = FastSin(90)
-LET r$ = FastRad(180)              ' Deg→rad (no FastTrig needed)
-FastTrig(FALSE)                     ' Free memory
-```
-Use for raycasting, sprite rotation, particle systems, any high-freq trig.
----
-## Command-Line Arguments
-```basic
-' bazzbasic.exe myprog.bas arg1 arg2
-PRINT ARGCOUNT         ' number of args (2 in this example)
-PRINT ARGS(0)          ' first arg  → "arg1"
-PRINT ARGS(1)          ' second arg → "arg2"
-```
-`ARGCOUNT` and `ARGS(n)` are 0-based; ARGS does not include the interpreter or script name.
----
-## Libraries & INCLUDE
-```basic
-INCLUDE "helpers.bas"               ' Insert source at this point
-INCLUDE "MathLib.bb"                ' Load compiled library
-' Compile library (functions only — no loose code)
-' bazzbasic.exe -lib MathLib.bas  →  MathLib.bb
-' Function names auto-prefixed: MATHLIB_functionname$
-PRINT FN MATHLIB_add$(5, 3)
-```
-Library functions can read main-program constants (`#`). `.bb` files are version-locked.
----
-## Passing Arrays to Functions
-Arrays cannot be passed directly to `DEF FN` functions, but a clean workaround exists using JSON serialization. Convert the array to a JSON string with `ASJSON`, pass the string as a parameter, then deserialize inside the function with `ASARRAY`. This is the accepted pattern in BazzBasic v1.2+.
-```basic
-DEF FN ProcessPlayer$(data$)
-    DIM arr$
-    LET count$ = ASARRAY(arr$, data$)
-    RETURN arr$("name") + " score:" + arr$("score")
-END DEF
-[inits]
-    DIM player$
-    player$("name") = "Alice"
-    player$("score") = 9999
-    player$("address,city") = "New York"
-[main]
-    LET json$ = ASJSON(player$)
-    PRINT FN ProcessPlayer$(json$)
-END
-```
-**Notes:**
-- The function receives a full independent copy — changes inside do not affect the original array
-- Nested keys work normally: `arr$("address,city")` etc.
-- Overhead is similar to copying an array manually; acceptable for most use cases
----
-## Program Structure
-```basic
-' ---- 1. FUNCTIONS (or INCLUDE "functions.bas") ----
-DEF FN Clamp$(v$, lo$, hi$)
-    IF v$ < lo$ THEN RETURN lo$
-    IF v$ > hi$ THEN RETURN hi$
-    RETURN v$
-END DEF
-' ---- 2. INIT (declare ALL constants & variables here, not inside loops) ----
-' Performance: variables declared outside loops avoid repeated existence checks.
-[inits]
-	LET SCREEN_W# = 640
-	LET SCREEN_H# = 480
-	LET MAX_SPEED# = 5
-    SCREEN 0, SCREEN_W#, SCREEN_H#, "My Game"
-    LET x$ = 320
-    LET y$ = 240
-    LET running$ = TRUE
-' ---- 3. MAIN LOOP ----
-[main]
-    WHILE running$
-        IF INKEY = KEY_ESC# THEN running$ = FALSE
-        GOSUB [sub:update]
-        GOSUB [sub:draw]
-        SLEEP 16
-    WEND
-    SOUNDSTOPALL
-END
-' ---- 4. SUBROUTINES (or INCLUDE "subs.bas") ----
-[sub:update]
-    IF KEYDOWN(KEY_LEFT#)  THEN x$ = x$ - MAX_SPEED#
-    IF KEYDOWN(KEY_RIGHT#) THEN x$ = x$ + MAX_SPEED#
-RETURN
-[sub:draw]
-    SCREENLOCK ON
-    LINE (0,0)-(SCREEN_W#, SCREEN_H#), 0, BF
-    CIRCLE (x$, y$), 10, RGB(0, 255, 0), 1
-    SCREENLOCK OFF
-RETURN
-```
-**Key conventions:**
-- Variables: `camelCase$` | Constants: `UPPER_SNAKE_CASE#` | Functions: `PascalCase$`
-- Labels: `[gameLoop]` for jump targets, `[sub:name]` for subroutines
-- Image/sound/shape IDs are stable integer handles — **always** store as constants: `LET MY_IMG# = LOADIMAGE("x.png")` — never use `$` variables for these
-- Group many IDs → use arrays: `DIM sprites$` / `sprites$("player") = LOADIMAGE(...)` — but prefer named constants when count is small
----
-## Performance Tips
-- `LINE (0,0)-(W,H), 0, BF` to clear — much faster than `CLS`
-- Always wrap draw code in `SCREENLOCK ON` / `SCREENLOCK OFF`
-- Store `RGB()` results in constants/variables — don't call RGB in hot loops
-- Declare all variables in `[inits]`, not inside loops or subroutines
-- Use `FastTrig` for any loop calling trig hundreds of times per frame
-- `SLEEP 16` in game loop → ~60 FPS
----
-## IDE Features (v1.3)
-### New File Template
-When the IDE opens with no file (or a new file), this template is auto-inserted:
-```basic
-' BazzBasic version 1.3
-' https://ekbass.github.io/BazzBasic/
-```
-### Beginner's Guide
-- **IDE:** Menu → **Help** → **Beginner's Guide** — opens `https://github.com/EkBass/BazzBasic-Beginners-Guide/releases` in default browser
-- **CLI:** `bazzbasic.exe -guide` or `bazzbasic.exe -help` — prints URL to terminal
-### Check for Updates
-- **IDE:** Menu → **Help** → **Check for updated...** — IDE reports if a newer version is available
-- **CLI:** `bazzbasic.exe -checkupdate`
-### Compile via IDE
-- **Menu → Run → Compile as Exe** — compiles open file to standalone `.exe` (auto-saves first)
-- **Menu → Run → Compile as Library (.bb)** — compiles open file as reusable `.bb` library (auto-saves first)