Upload BazzBasic-AI-guide.txt

Updated for BazzBasic ver. 1.3b to be released 19th April 2026

BazzBasic-AI-guide.txt

@@ -0,0 +1,603 @@
+---
+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)