Update SKILL.md

SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: bazzbasic-code
-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. For changing the interpreter or IDE source code use bazzbasic-interpreter-dev or bazzbasic-ide-dev."
+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.6 | **Author:** Kristian Virtanen (EkBass) | **Platform:** Windows x64 only (SDL2 via P/Invoke — no Linux, macOS, browser or Android)  
+**Version:** 1.6 | **Author:** Kristian Virtanen (EkBass) | **Platform:** Windows x64  
 **Homepage:** https://ekbass.github.io/BazzBasic/  
 **GitHub:** https://github.com/EkBass/BazzBasic  
 **Manual:** https://ekbass.github.io/BazzBasic/manual/#/  
@@ -13,8 +13,7 @@ description: "BazzBasic BASIC interpreter language reference. Use when writing,
 **Rosetta Code solutions:** https://github.com/EkBass/BazzBasic/tree/main/Examples/rosetta-code  
 **BazzBasic-AI-Guide:** https://huggingface.co/datasets/EkBass/BazzBasic_AI_Guide  
 **BazzBasic Beginner's Guide:** https://github.com/EkBass/BazzBasic-Beginners-Guide/releases  
-
-BazzBasic is a BASIC meant for beginners and for small, fun experiments (simple games, quizzes, bouncing balls). It is not a high-performance game engine — keep generated code simple and readable rather than clever.
+**Communities:** https://ekbass.github.io/BazzBasic/communities.html
 
 ---
 
@@ -22,26 +21,22 @@ BazzBasic is a BASIC meant for beginners and for small, fun experiments (simple
 
 | Rule | Detail |
 |------|--------|
-| Variables end with `$` | `name$`, `score$`, `x$` — the suffix does NOT mean string type |
-| Constants end with `#` | `MAX#`, `PI#`, `TITLE#` — `#` only means immutable |
+| 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` |
-| Case-insensitive | Keywords, variables and labels. Only string contents are case-sensitive |
-| Functions defined **before** they are called | Put at top or INCLUDE — forward references don't resolve |
+| 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$()` |
-| `DEF FN` scope is fully isolated | Only global `#` constants are visible. No `$` variables, no global arrays. Arrays cannot be passed as parameters — see *Passing Arrays to Functions* |
-| `+` does both add and concatenate | If either side is a string, the other is auto-converted: `"Score: " + 5` → `"Score: 5"`, no `STR()` needed |
+| 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$` — if either side is a string, the other is auto-converted: `"Score: " + 5` → `"Score: 5"`, no `STR()` needed |
 | Division always returns float | `10 / 3` → `3.333...` |
-| Division by zero returns `0` silently | Guard with `IF b$ = 0 THEN ...` if correctness matters |
+| Division by zero returns `0` (no error) | Guard with `IF b$ = 0 THEN ...` if needed |
 | No integer-division operator | Use `INT(a / b)`, `FLOOR(a / b)`, or `CINT(a / b)` |
 | Errors halt the program | No `TRY`/`CATCH` or `ON ERROR` — line-numbered message printed |
-| No line-continuation char | Leave an operator at line end or open a `(` — see *Line Continuation* |
-| No line numbers | Never supported. Use `[labels]` |
-| `:` separates statements on one line | `FOR i$ = 1 TO 3 : PRINT i$ : NEXT`. A `:` inside a label like `[sub:init]` is part of the label name, not a separator |
-| `NOT` binds tighter than comparisons | `NOT a$ = b$` means `(NOT a$) = b$`. Parenthesize: `IF NOT (a$ = b$) THEN`, or use `<>` |
-| Comments: `'` or `REM` | `' comment` anywhere on a line; `REM` as a statement, also after `:` (`PRINT x$ : REM note`) |
+| No line-continuation char | Don't use `_`, `\`, or `&` — lexer continues automatically after operators or open `(` |
 
 ---
 
@@ -58,51 +53,79 @@ DEF FN doStuff(a, b)                      DEF FN DoStuff$(a$, b$)
 FN MyFunc$(5)       ' return ignored      LET v$ = FN MyFunc$(5)
 LET handle$ = LOADIMAGE("x.png")          LET HANDLE# = LOADIMAGE("x.png")
 CLS                 ' in graphics mode    LINE (0,0)-(W,H), 0, BF
-PRINT "x:", x$      ' in graphics mode    DRAWSTRING "x:" + x$, 10, 10, WHITE#
+PRINT "x:", x$      ' in graphics mode    DRAWSTRING "x:" + STR(x$), 10, 10, RGB(255,255,255)
 FSTRING("Hi {{name$}}") ' Python-style    FSTRING("Hi {{-name$-}}")     ' triple-char markers
 ISSET(arr$(0))   ' expecting error        ' returns 0 silently — ISSET only sees scalars
 LET x$ = a$ + _ ' VBA continuation        LET x$ = a$ +     ' just leave the operator
-LET x$ = a$ + \ ' Python continuation     LET x$ = a$ +     ' or open a paren
-IF NOT a$ = b$ THEN    ' QBASIC habit     IF NOT (a$ = b$) THEN
+LET x$ = a$ + \ ' Python continuation     LET x$ = a$ +     ' or open a paren — see Line Continuation
 ```
 
----
-
-## When Generating BazzBasic Code
+**Two more traps that don't fit the table:**
 
-- Prefer `FSTRING` over long `+` concatenation chains for multi-variable strings
-- Place `DEF FN` definitions at the top of the file or via `INCLUDE`
-- Store every `LOADIMAGE` / `LOADSOUND` / `LOADSHAPE` handle as a `#` constant. They return stable integer handles owned by SDL2 that never change. For many handles, an array is fine: `sprites$("player") = LOADIMAGE(...)`
-- Declare all variables and constants in `[inits]`, not inside loops — this avoids repeated existence checks
-- Precompute colors: `LET WHITE# = RGB(255, 255, 255)` in `[inits]`, never `RGB()` inside a game loop
-- In graphics mode: clear with `LINE (0,0)-(W,H), 0, BF` (much faster than `CLS`), draw text with `DRAWSTRING` (`PRINT` flickers), and wrap each frame in `SCREENLOCK ON` / `SCREENLOCK OFF`
-- If a feature isn't documented in this guide, say so rather than inventing one — BazzBasic does not silently inherit QBASIC, FreeBASIC, or VB conventions
+- Inside `DEF FN` you can read `#` constants from the outer scope but **not** `$` variables or global arrays. Pass values as parameters.
+- Arrays cannot be passed to a function directly, and a function cannot see global arrays. Serialize with `ASJSON()` and rebuild inside the function with `ASARRAY()` — see *Passing Arrays to Functions* below.
 
 ---
 
 ## Minimal Valid Program
 
 ```basic
-[inits]                     ' [name] is a plain jump label, not a keyword
+' Suggested style to use [subs]
+[inits]                     ' [name] is a plain jump label, not a keyword — see Control Flow
     LET name$ = "World"
 
 [main]
     PRINT "Hello, " + name$
 END
 
-' subroutines go after END
+' other subs after END'
 [sub:drawScreen]
-    ' draw
+	' draw
 RETURN
 ```
 
-Programs flow top to bottom. `[inits]` and `[main]` are organizational labels, not required syntax. `END` halts execution; place it at the end of the main flow so control doesn't fall through into subroutines.
+Programs flow top to bottom. `[inits]` and `[main]` are organizational labels, not required syntax — the file would also run without them. `END` halts execution; place it at the end of the main flow so control doesn't fall through into subroutines or function definitions.
+
+---
+
+## When Generating BazzBasic Code
+
+(Suffix and return-value rules are already covered in Critical Rules above — not repeated here.)
+
+- Prefer `FSTRING` over long `+` concatenation chains for multi-variable strings
+- Place `DEF FN` definitions at the top of the file or via `INCLUDE`
+- Store every `LOADIMAGE` / `LOADSOUND` / `LOADSHAPE` handle as a `#` constant
+- In graphics mode, prefer `LINE (0,0)-(W,H), 0, BF` over `CLS`, and `DRAWSTRING` over `PRINT`
+- Wrap each frame's drawing in `SCREENLOCK ON` / `SCREENLOCK OFF`
+- If a feature isn't documented in this guide, say so rather than inventing one — BazzBasic does not silently inherit QBASIC, FreeBASIC, or VB conventions
+
+---
+
+
+## ABOUT
+
+BazzBasic is built around one simple idea: starting programming should feel nice, even fun — the ease and small joyful moments of the classic BASICs of decades past, with a fresh, modern feel.
+
+Over the years my own skills have grown and I've moved on to more versatile languages, but BASIC has always stayed fun for quick experiments — a simple adventure game, a lottery machine, a quiz, or just balls bouncing on the screen. BazzBasic was built with that in mind: a language that gets out of your way so curiosity can run free. And when you finish your first little game and crave something bigger, and eventually move on to another language — that's BazzBasic succeeding at exactly what it was meant to do.
+
+To arouse your curiosity.
+
+*EkBass*, author of BazzBasic
+
+---
+
+## Case sensitivity
+BazzBasic is not case-sensitive except with string contents.
+```basic
+let blaa$ = "Hello"
+PriNT BLAA$ ' output: Hello
+```
 
 ---
 
 ## Line Continuation
 
-The lexer figures out continuation automatically using two rules. Never emit `_`, `\`, `&` or any other continuation marker.
+BazzBasic has **no line-continuation character**. Do not generate `_` (VBA), `\` (Python), or `&` (other dialects). The lexer figures out continuation automatically using two rules.
 
 **Rule 1 — operator at end of line.** If a line ends in a token that cannot legally end an expression, the next line continues it:
 
@@ -121,7 +144,8 @@ LET counter$ +=
 
 Tokens that trigger this: `+ - * / % = <> < <= > >= AND OR += -= *= /= ,`
 
-> `%` is a real binary modulo operator and triggers continuation. `MOD(a, b)` is a function, so it does not (a `)` at line end never continues).
+> `%` IS a real binary modulo operator (`a % b`, same precedence as `*`/`/`, same result as `MOD(a, b)`) and DOES trigger continuation like the other arithmetic operators above.
+> `MOD` is a separate thing — a function `MOD(a, b)` — not a binary operator, so it does NOT trigger continuation (a `)` at line end never continues).
 
 **Rule 2 — open paren.** Anything inside an unmatched `(` keeps reading until the matching `)`:
 
@@ -132,90 +156,115 @@ LET dist$ = DISTANCE(
 )
 ```
 
+Both rules combine:
+
+```basic
+LET total$ = (
+    base$ +
+    tax$
+)
+```
+
+**Trap for AI generators.** Do NOT emit a trailing `_`, `\`, `&`, or any other continuation marker — they are not BazzBasic syntax and will produce parse errors. Just leave the operator at the end of the line, or open a paren.
+
 ---
 
 ## Variables & Constants
+Variables and constants must be declared with LET before they can be used.  
+BazzBasic variables are not typed, but work the same way as in JavaScript, for example.  
+A variable needs the suffix $ which often is linked as STRING in traditional basic variants.  
 
-Variables are dynamically typed, like in JavaScript.
-
+Variables require suffix "$". Constants require suffix "#".
+The suffix does not define data type — only "#" indicates immutability.
 ```basic
-LET a$                          ' Declare without value
-LET b$, c$, d$                  ' Multiple declarations without value
-LET e$, f$ = "foo", g$ = 10     ' e$ stays empty, f$ and g$ get values
+LET a$                      ' Declare variable without value
+LET b$, c$, d$				' Multiple variable declarations without value
+LET e$, f$ = "foo", g$ = 10	' Multiple variable declaration, e$ stays empty, f$ and g$ gets values
 
-LET name$ = "Alice"             ' String
-LET score$ = 0                  ' Number
+LET name$ = "Alice"         ' String variable
+LET score$ = 0              ' Numeric variable
 
-LET PI# = 3.14159               ' Constant (immutable)
-LET TITLE# = "My Game"          ' String constant
+LET PI# = 3.14159           ' Constant (immutable)
+LET TITLE# = "My Game"      ' String constant
 ```
 
-**Compound assignment** (variables only — **not** allowed with `#` constants):
+**Compound assignment operators** (variables only — **not** allowed with `#` constants):
 
 ```basic
 LET x$ = 1
-x$ += 5
-x$ -= 3
-x$ *= 2
-x$ /= 4
+x$ += 5     ' add
+x$ -= 3     ' subtract
+x$ *= 2     ' multiply
+x$ /= 4     ' divide
 LET s$ = "Hello"
-s$ += " World"  ' concatenation
+s$ += " World"  ' string concatenation
 ```
 
-**Scope:** All main-code variables share one scope — `IF`, `FOR`, and `WHILE` do NOT create a new scope.
+**Scope:** All main-code variables share one scope (IF, FOR, and WHILE do NOT create new scope).  
+Main-code variables ($) and arrays are NOT accessible inside DEF FN.  
+`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` (`1`), `FALSE` (`0`) — plain numbers. `IF x$ = 1` and `IF x$ = TRUE` are identical.
-- **Math:** `PI#`, `HPI#` (π/2 = 90°), `QPI#` (π/4 = 45°), `TAU#` (2π = 360°), `EULER#` (e)
-- **System:** `PRG_ROOT#` (program base directory path, ends with a separator)
-- **Version:** `BBVER#` (current BazzBasic version as a string, e.g. `"1.6"`)
-- **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_NUMPAD0#`…`KEY_NUMPAD9#`, `KEY_NUMPAD_PLUS#`, `_MINUS#`, `_MUL#`, `_DIV#`, `_DOT#`, `KEY_LSHIFT#`, `KEY_LCTRL#`, `KEY_RSHIFT#`, `KEY_RCTRL#`, `KEY_LALT#`, `KEY_RALT#`, `KEY_LWIN#`/`KEY_RWIN#`, `KEY_TAB#`, `KEY_BACKSPACE#`, `KEY_INSERT#`, `KEY_DELETE#`, `KEY_HOME#`, `KEY_END#`, `KEY_PGUP#`, `KEY_PGDN#` — see *Keyboard Input*
-- **Gamepad:** see *Gamepad*
+- **Boolean:** `TRUE` (`1`), `FALSE` (`0`) — plain numbers, not a separate type. `IF x$ = 1` and `IF x$ = TRUE` are identical.
+- **Math:** `PI#`, `HPI#` (π/2 = 90°), `QPI#` (π/4 = 45°), `TAU#` (2π = 360°), `EULER#` (e) — `#` suffix required
+- **System:** `PRG_ROOT#` (program base directory path)
+- **Version:** `BBVER#` (returns current version of BazzBasic, ie: "1.6")
+- **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_NUMPAD0#`…`KEY_NUMPAD9#`, `KEY_NUMPAD_PLUS#`/`_MINUS#`/`_MUL#`/`_DIV#`/`_DOT#`, `KEY_LSHIFT#`, `KEY_LCTRL#`, etc. — see *Keyboard Input*
+- **Gamepad:** buttons `PAD_A#`…`PAD_Y#`, `PAD_UP#`/`_DOWN#`/`_LEFT#`/`_RIGHT#`, `PAD_LB#`, `PAD_RB#`, `PAD_START#`, `PAD_BACK#` etc.; axes `PAD_LX#`, `PAD_LY#`, `PAD_RX#`, `PAD_RY#`, `PAD_LT#`, `PAD_RT#` — see *Gamepad*
 
 ---
 
 ## Arrays
+BazzBasic arrays are fully dynamic and support numeric, string, or mixed indexing.  
 
-Arrays are fully dynamic and support numeric, string, or mixed indexing.
 
 ```basic
 DIM scores$                         ' Declare (required before use)
 DIM a$, b$, c$                      ' Multiple
-scores$(0) = 95                     ' Numeric indices are 0-based
-scores$("name") = "Alice"           ' String keys: associative, insertion-ordered
+scores$(0) = 95                     ' Numeric indices are 0-based.
+scores$("name") = "Alice"           ' String keys are associative, insertion-ordered.
 matrix$(0, 1) = "A2"                ' Multi-dimensional
 
 DIM sounds$
-    sounds$("guns", "shotgun_shoot") = "shoot_shotgun.wav"
-    sounds$("guns", "ak47_shoot")    = "shoot_ak47.wav"
-    sounds$("food", "ham_eat")       = "eat_ham.wav"
+    sounds$("guns", "shotgun_shoot")    = "shoot_shotgun.wav"
+    sounds$("guns", "shotgun_reload")   = "reload_shotgun.wav"
+    sounds$("guns", "ak47_shoot")       = "shoot_ak47.wav"
+    sounds$("guns", "ak47_reload")      = "reload_ak47.wav"
+    sounds$("food", "ham_eat")          = "eat_ham.wav"
 
-PRINT LEN(sounds$())        ' 3 - total elements across all groups
-PRINT ROWCOUNT(sounds$())   ' 2 - "guns" & "food"
+PRINT LEN(sounds$())        ' 5 - total elements across both "guns" and "food" groups
+PRINT ROWCOUNT(sounds$())   ' 2, "guns" & "food"
 
 DIM car$
     car$("manufacturer") = "Ford"
     car$("engine")       = "1.6 Eco"
+    car$("color")        = "Blue"
 
-FOR i$ = 0 TO LEN(car$()) - 1        ' No FOREACH — LEN + ARRKEY is the idiom
-    LET key$ = ARRKEY(car$(), i$)
+FOR i$ = 0 TO LEN(car$()) - 1        ' Iterate an associative array: LEN + ARRKEY
+    LET key$ = ARRKEY(car$(), i$)    ' No FOREACH in BazzBasic - this is the idiom
     PRINT key$; " = "; car$(key$)
 NEXT i$
 ```
 
 | Function/Command | Description |
 |-----------------|-------------|
-| `LEN(arr$())` | Total element count across all dimensions |
+| `LEN(arr$())` | Total element count (LEN counts all nested elements across all dimensions) |
 | `ROWCOUNT(arr$())` | Count of first-dimension rows — use this for FOR loops over multi-dim arrays |
-| `ARRKEY(arr$(), i)` | Key at 0-based index `i`, in insertion order. Errors on out-of-range index |
-| `HASKEY(arr$(key))` | 1 if exists, 0 if not — **always check before reading possibly uninitialized elements** |
+| `ARRKEY(arr$(), i)` | Key at 0-based index `i`, in insertion order. Pair with `LEN` to loop over string-keyed arrays with `FOR/NEXT` or `WHILE/WEND`. Errors on out-of-range index. |
+| `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; matching `src2$` keys overwrite `src1$` at the same level. Use an empty `src1$` to copy an array |
+| `JOIN dest$, src1$, src2$` | Merge two arrays; `src2$` keys overwrite `src1$`. Use empty `src1$` as `COPYARRAY`. |
+
+**JOIN** Matching keys from src2$ overwrite src1$ at the same level
+
+**Always check with `HASKEY` before reading uninitialized elements.**
 
-> `DIM arr$ = value` stores the value at `arr$(0)` — NOT as a scalar. If a scalar is what you want, use `LET`.
+> `DIM arr$ = value` (single value, not `key=value` text) stores it at `arr$(0)` — NOT as a scalar. `DIM x$ = 5` does not make `x$` printable as a plain number; it makes `x$(0)` equal `5`. If a scalar is what you want, use `LET`, not `DIM`.
 
 ---
 
@@ -244,10 +293,22 @@ WHILE x$ < 100
     x$ = x$ * 2
 WEND
 
+' Leave a loop early: EXIT WHILE / EXIT FOR (innermost loop of that kind)
+WHILE 1
+    IF INKEY = KEY_ESC# THEN EXIT WHILE
+WEND
+FOR i$ = 1 TO 100
+    IF i$ * i$ > 50 THEN EXIT FOR     ' i$ keeps its value (8)
+NEXT
+' Use EXIT, not GOTO, to leave a loop: GOTO leaves stale loop state behind.
+' EXIT WHILE inside a FOR inside a WHILE leaves both. Inside DEF FN, EXIT only
+' leaves loops inside the function. No EXIT DEF / EXIT GOSUB (use RETURN).
+
 ' Labels, GOTO, GOSUB
 [start]
     GOSUB [sub:init]
-    GOTO [start]            ' Avoid jumping into the middle of IF/WHILE blocks
+	' Avoid jumping into the middle of logical blocks (e.g. inside IF/WHILE)
+    GOTO [start]
 
 [sub:init]
     LET x$ = 0
@@ -257,59 +318,77 @@ RETURN
 LET target$ = "[menu]"
 GOTO target$
 
+' Other
 SLEEP 2000                  ' Pause for milliseconds
 END                         ' Terminate program
 ```
-
-Labels may contain almost any printable character. Whitespace is trimmed; everything between `[` and `]` is the label name.
-
+**Note:** Labels are case-insensitive and may contain almost any printable character.
+Whitespace is trimmed. Everything between "[" and "]" is treated as the label name.
 ---
 
 ## I/O
 
 | Command | Description |
 |---------|-------------|
-| `PRINT expr; expr` | `;` = no space, `,` = tab, can be mixed |
+| `PRINT expr; expr` | `;` = no space, `,` = tab |
 | `PRINT "text";` | Trailing `;` suppresses newline |
-| `INPUT "prompt", var$` | Splits on whitespace/comma; quoted strings are single values |
+| `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 (console) |
+| `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, palette 0–15 only (`RGB()` does not work here) |
-| `GETCONSOLE(row, col, type)` | Read console cell. type: 0=char (ASCII), 1=fg color, 2=bg color |
+| `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` `\\` `""`
+' ; prints without spacing
+' , prints tab separation
+' Both can be mixed in a single PRINT statement
+' INPUT splits on whitespace and comma; quoted strings are treated as single values
+
+**Escape sequences in strings:** `\"` `\n` `\t` `\\`
 
-**SHELL + SQLite.** The `sqlite3` CLI is the recommended way to add a database — see the *SQLite Database* page in the manual. When wrapping SQL in SHELL:
-- Always append `2>&1`, or SQL errors disappear silently.
-- Wrap the SQL with `\"`: `SHELL("sqlite3 db.sqlite \"SELECT * FROM users\" 2>&1")`.
+**SHELL + SQLite.** SQLite (the `sqlite3` CLI tool) is the recommended way to add a real database to a BazzBasic script — see the *SQLite Database* page in the manual for the full guide. Three things to remember when generating SHELL commands that wrap SQL:
+- Always append `2>&1` to the command, or SQL errors disappear silently.
+- Use `\"` (BazzBasic escape) to wrap the SQL for the OS shell: `SHELL("sqlite3 db.sqlite \"SELECT * FROM users\" 2>&1")`.
 - In paths use `/` or `\\` — never a single `\`.
 
 ### Keyboard Input
 | Function | Returns | Notes |
 |----------|---------|-------|
 | `INKEY` | Key value or 0 | Non-blocking |
-| `KEYDOWN(key#)` | TRUE/FALSE | Held-key detection, graphics mode only |
+| `KEYDOWN(key#)` | TRUE/FALSE | Held-key detection; KEYDOWN only works in graphics mode |
 | `WAITKEY(key#, ...)` | Key value | Blocks until key pressed; `WAITKEY()` = any key |
 
-- **Layout-safe keys:** letters, digits, arrows, Space/Enter/Esc, F-keys, numpad and modifiers are the same on every layout — use these for controls. Main-keyboard punctuation (`+ - = , . /`) depends on the layout: never bind controls to `ASC("+")` or `ASC("-")`; use letters or `KEY_NUMPAD_PLUS#` / `KEY_NUMPAD_MINUS#`.
-- Letters always return uppercase codes (`"a"` and `"A"` → `KEY_A#`), in both graphics and console mode.
-- `KEYDOWN` follows the key *label* on the current layout, same as `INKEY`. If no key types a punctuation character without modifiers (e.g. `=` on a Finnish keyboard), `KEYDOWN` of that constant is always FALSE.
-- Numpad Enter = `KEY_ENTER#`.
-- `INKEY` consumes the key: read it once per loop pass (`LET k$ = INKEY`) and compare the variable. A second `INKEY` in the same pass returns 0.
-- Console mode: `INKEY`/`WAITKEY` return the typed character (except letters and special keys); numpad returns the typed digit, not `KEY_NUMPAD*#`.
+**Keyboard layouts.** Letters (`KEY_A#`…`KEY_Z#`), digits, arrows, Space/Enter/Esc, F-keys,
+numpad and modifiers are the same on every keyboard layout — use these for controls.
+Main-keyboard punctuation (`+ - = , . /` etc. and their `KEY_*#` constants) depends on the
+layout: never bind controls to `ASC("+")` or `ASC("-")`. Use letters or
+`KEY_NUMPAD_PLUS#` / `KEY_NUMPAD_MINUS#` instead.
 
+- Letters always return uppercase codes (`"a"` and `"A"` → `KEY_A#`), in both graphics and console mode.
+- `KEYDOWN` follows the key *label* on the current layout, same as `INKEY`: `KEYDOWN(KEY_A#)` is the key that types "a" (on AZERTY that is a different physical key than on QWERTY). If no key types a punctuation character without modifiers (e.g. "=" on a Finnish keyboard), `KEYDOWN` of that constant is always FALSE.
+- Numpad: `KEY_NUMPAD0#`…`KEY_NUMPAD9#`, `KEY_NUMPAD_PLUS#`, `KEY_NUMPAD_MINUS#`,
+  `KEY_NUMPAD_MUL#`, `KEY_NUMPAD_DIV#`, `KEY_NUMPAD_DOT#` (graphics mode). Numpad Enter = `KEY_ENTER#`.
+- INKEY consumes the key: read it once per loop pass into a variable (`LET k$ = INKEY`)
+  and compare the variable. Two `INKEY` calls in one pass → the second returns 0.
+- Console mode: INKEY/WAITKEY return the typed character (except letters and special keys);
+  numpad returns the typed digit, not `KEY_NUMPAD*#`. KEYDOWN is graphics-only.
+  
 ### Mouse (graphics mode only)
 `MOUSEX`, `MOUSEY` — cursor position  
-`MOUSELEFT`, `MOUSERIGHT`, `MOUSEMIDDLE` — 1 if pressed, 0 otherwise  
-`MOUSEHIDE` / `MOUSESHOW` — hide / restore the cursor
+`MOUSELEFT`, MOUSERIGHT, MOUSEMIDDLE — return 1 if pressed, 0 otherwise  
+`MOUSEHIDE` — hide the mouse cursor (graphics screen only)  
+`MOUSESHOW` — restore the mouse cursor (graphics screen only)
+
+### Gamepad (console AND graphics mode) — added in v1.5
+
+> **DISCLAIMER:** BazzBasic version 1.5 has been tested with only one PS4-compatible Bluetooth controller. Therefore, for the time being, I cannot guarantee that GamePad support will work with all different types of controllers.
+
+When a user reports a pad not being detected, wrong button mapping or odd axis values, keep this in mind: it may be an untested-controller issue rather than a bug in their code.
 
-### Gamepad (console AND graphics mode)
 | Function | Returns | Notes |
 |----------|---------|-------|
 | `GAMEPADS()` | Number of connected pads | Parentheses optional |
@@ -318,48 +397,57 @@ Labels may contain almost any printable character. Whitespace is trimmed; everyt
 | `PADNAME(pad)` | String | e.g. `"PS4 Controller"`, `""` if not connected |
 | `PADRUMBLE pad, strength, ms` | — (statement) | strength 0.0…1.0, non-blocking, parentheses optional |
 
-- Pad index is **0-based**, max 8 pads. Slots are stable while connected (not re-packed on disconnect). Hot-plug works.
-- **No `SCREEN` needed** — works in console programs too.
-- **Disconnected pad = no input, never an error:** `PADBUTTON` → FALSE, `PADAXIS` → 0, `PADNAME` → `""`. Don't guard every read with `IF GAMEPADS() > 0`; use `GAMEPADS()` only to show a "connect a pad" message.
-- Buttons (Xbox naming): `PAD_A#` `PAD_B#` `PAD_X#` `PAD_Y#`, `PAD_UP#` `PAD_DOWN#` `PAD_LEFT#` `PAD_RIGHT#`, `PAD_LB#` `PAD_RB#`, `PAD_LSTICK#` `PAD_RSTICK#`, `PAD_BACK#` `PAD_START#` `PAD_GUIDE#`, `PAD_MISC#`, `PAD_TOUCHPAD#`. PlayStation: A=Cross, B=Circle, X=Square, Y=Triangle. Raw 0–20 valid (16–19 = Elite paddles); outside → error.
-- Axes: `PAD_LX#` `PAD_LY#` `PAD_RX#` `PAD_RY#` `PAD_LT#` `PAD_RT#`. Raw 0–5; outside → error.
-- **Y axis: negative = up**, same as screen Y. `y$ = y$ + PADAXIS(0, PAD_LY#) * SPEED#` is correct — do not invert.
-- **L2/R2 are triggers, not buttons:** read with `PADAXIS(pad, PAD_LT#)`. Never pass an axis constant to `PADBUTTON` — `PADBUTTON(0, PAD_LT#)` silently reads button 4 (`PAD_BACK#`).
-- For one action per press, keep previous state: `IF now$ = TRUE AND was$ = FALSE THEN ...` then `was$ = now$`.
+- Pad index is **0-based**, max 8 pads. A pad keeps its number while connected (stable slots, not re-packed on disconnect).
+- **No `SCREEN` needed** — unlike `KEYDOWN`/mouse, gamepad functions work in console programs too.
+- **Disconnected pad = no input, never an error:** `PADBUTTON` → FALSE, `PADAXIS` → 0, `PADNAME` → `""`. Do not generate guard code like `IF GAMEPADS() > 0 THEN` around every read; use `GAMEPADS()` only to show a "connect a pad" message.
+- Hot-plug works: pads connected while the program runs are picked up automatically.
+- Button constants (Xbox naming): `PAD_A#` `PAD_B#` `PAD_X#` `PAD_Y#`, `PAD_UP#` `PAD_DOWN#` `PAD_LEFT#` `PAD_RIGHT#`, `PAD_LB#` `PAD_RB#`, `PAD_LSTICK#` `PAD_RSTICK#`, `PAD_BACK#` `PAD_START#` `PAD_GUIDE#`, `PAD_MISC#`, `PAD_TOUCHPAD#`. PlayStation: A=Cross, B=Circle, X=Square, Y=Triangle. Raw numbers 0–20 are valid (16–19 = Elite paddles); outside that → error.
+- Axis constants: `PAD_LX#` `PAD_LY#` `PAD_RX#` `PAD_RY#` `PAD_LT#` `PAD_RT#`. Raw 0–5; outside → error.
+- **Y axis: negative = up**, same direction as screen Y. So `y$ = y$ + PADAXIS(0, PAD_LY#) * SPEED#` moves correctly — do not invert it.
+- **L2/R2 are triggers, not buttons.** Read them with `PADAXIS(pad, PAD_LT#)` / `PADAXIS(pad, PAD_RT#)`. Never pass an axis constant to `PADBUTTON`: constants are plain numbers, so `PADBUTTON(0, PAD_LT#)` silently reads button 4 (= `PAD_BACK#`) with no error.
+- `PADBUTTON` is TRUE every frame while held. For one action per press, keep the previous state: `IF now$ AND NOT was$ THEN ...` then `was$ = now$`.
 - Stick as digital direction: `IF PADAXIS(0, PAD_LX#) < -0.5 THEN ...`
-- Pad OR keyboard: `IF PADBUTTON(0, PAD_LEFT#) OR KEYDOWN(KEY_LEFT#) THEN dx$ = -1`
-- Many third-party pads identify as PS4/Xbox controllers — normal, mapping is still correct.
+- Typical game input = pad OR keyboard: `IF PADBUTTON(0, PAD_LEFT#) OR KEYDOWN(KEY_LEFT#) THEN dx$ = -1`
+- Many third-party pads identify as PS4/Xbox controllers — normal, mapping still correct.
+
+### Console Read
+Returns numeric or character depending on type parameter  
+`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)          ' ✓ return value used
-LET v$ = FN Clamp$(15, 0, 10)      ' ✓
+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
 ```
 
-- Scope is isolated (see *Critical Rules*). Touching a global array gives: `Global array G$ is not visible inside DEF FN - pass it as a parameter with ASJSON() and rebuild it with ASARRAY()`
-- `DIM` inside a function creates a **fresh, empty, local** array on every call and every recursion level:
-```basic
+- Isolated scope: no access to global `$` variables or global arrays, only global constants (`#`). Using a global array inside a function is an error: `Global array G$ is not visible inside DEF FN - pass it as a parameter with ASJSON() and rebuild it with ASARRAY()`
+- **Arrays inside functions:** `DIM` inside a function always creates a **fresh, empty, local** array on every call (and on every recursion level). Local arrays do not survive between calls:
+  ```basic
   DEF FN Count$(x$)
-      DIM t$
+      DIM t$          ' new empty array on every call
       t$(x$) = 1
       RETURN LEN(t$())
   END DEF
   PRINT FN Count$(1)  ' 1
   PRINT FN Count$(2)  ' 1 (not 2)
-```
-- Parameters are passed **by value**
+  ```
+  (In v1.4c and older, arrays `DIM`'d in a function kept their contents between calls, and functions could accidentally reach global arrays by name.)
+- Parameters passed **by value**
 - Labels inside functions are local — GOTO/GOSUB cannot jump outside
-- Recursion uses the real call stack, so thousands of levels can overflow it. GOSUB/RETURN uses a separate heap-based stack with no such limit.
+- Supports recursion — uses the real call stack, so extremely deep recursion (thousands of levels) can overflow it. GOSUB/RETURN uses a separate, heap-based stack with no such limit.
+- 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
 
 ---
 
@@ -369,8 +457,9 @@ FN Clamp$(5, 1, 10)                ' ✗ ERROR — return value unused
 |----------|-------------|
 | `ASC(s$)` | ASCII code of first char |
 | `CHR(n)` | Character from ASCII code |
-| `INSTR(s$, search$)` | Position (1-based), 0=not found; case-sensitive |
+| `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 |
@@ -380,18 +469,24 @@ FN Clamp$(5, 1, 10)                ' ✗ ERROR — return value unused
 | `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 (keys `0`..`count-1`), returns count. Array is emptied first. `arr$()` also accepted |
-| `SRAND(n)` | Random alphanumeric string of length n. `n = 0` → `""`; **negative n crashes** with an overflow error — never pass an unvalidated length |
+| `SPLIT(arr$, s$, sep$)` | Split into array (keys `0`..`count-1`), returns count. The array is emptied first, so re-splitting a shorter string leaves no old elements. `arr$()` also accepted as first argument |
+| `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 |
 
+> `SRAND(n)` with `n < 0` throws an unhandled arithmetic error (`n = 0` is safe, returns `""`). Never pass an unvalidated or negative length.
+> ```basic
+> PRINT SRAND(-1)
+> ' Error: Arithmetic operation resulted in an overflow.
+> ```
+
 ---
 
 ## FSTRING — String Interpolation
 
-`FSTRING(template$)` substitutes `{{-name-}}` placeholders with the value of variables, constants, or array elements.
+`FSTRING(template$)` substitutes `{{-name-}}` placeholders inside a template string with the value of variables, constants, or array elements. Preferred over long `+` concatenation chains.
 
 ```basic
 LET name$ = "Krisu"
@@ -400,28 +495,39 @@ PRINT FSTRING("Hello {{-name$-}}, level {{-LEVEL#-}}")
 ' Output: Hello Krisu, level 5
 ```
 
-The triple-character markers `{{-` and `-}}` are deliberately unusual. There is no escape syntax — literal `{{-...-}}` is always parsed as a placeholder.
+The triple-character markers `{{-` and `-}}` are deliberately unusual so they will not collide with normal text. There is no escape syntax — literal `{{-...-}}` in the template is always parsed as a placeholder.
+
+### Placeholder forms
 
 | Form | Resolves to |
 |------|-------------|
-| `{{-var$-}}` | Variable `var$` |
-| `{{-CONST#-}}` | Constant `CONST#` (built-ins like `{{-PI#-}}` work too) |
-| `{{-arr$(0)-}}` | Element at numeric index `0` |
-| `{{-arr$(i$)-}}` | Element at index from variable `i$` |
-| `{{-arr$(KEY#)-}}` | Element at index from constant `KEY#` |
-| `{{-arr$(name)-}}` | Element at literal string key `"name"` (no quotes inside FSTRING) |
-| `{{-arr$(0, i$)-}}` | Multidimensional, mixed literal and variable indices |
-
-**Index resolution** — for each comma-separated index, FSTRING checks:
+| `{{-var$-}}` | Value of variable `var$` |
+| `{{-CONST#-}}` | Value of constant `CONST#` |
+| `{{-arr$(0)-}}` | Array element at numeric index `0` |
+| `{{-arr$(i$)-}}` | Array element at index taken from variable `i$` |
+| `{{-arr$(KEY#)-}}` | Array element at index taken from constant `KEY#` |
+| `{{-arr$(name)-}}` | Array element at literal string key `"name"` (no quotes inside FSTRING) |
+| `{{-arr$(0, i$)-}}` | Multidimensional element, mixed literal and variable indices |
+
+### Index resolution rule (array access)
+
+For each comma-separated index, FSTRING looks at the last character:
+
 1. Ends with `$` or `#` → variable / constant lookup. Halts if undefined.
-2. Parses as a number → numeric index. `arr$(01)` and `arr$(1.0)` both resolve to key `1`.
-3. Otherwise → literal string key.
+2. Parses as a number (`0`, `1.5`, `-3`) → numeric index. `arr$(01)` and `arr$(1.0)` both resolve to key `1`.
+3. Otherwise → literal string key. This is what lets `{{-player$(name)-}}` read what was stored with `player$("name") = ...`.
+
+### Notes
 
-So `{{-name-}}` (no suffix) is a literal array key, **not** variable `name$`. Always include the suffix.
+- Whitespace inside placeholders is trimmed: `{{- name$ -}}` ≡ `{{-name$-}}`.
+- Built-in constants work too (`{{-PI#-}}`, `{{-EULER#-}}`, `{{-arr$(KEY_A#)-}}`) — checked before user variables, same order as normal expressions. (In v1.4c they failed with "undefined variable".)
+- Numbers auto-stringify — no `STR()` needed for numeric variables, constants, or array elements.
+- FSTRING returns a value; you must use it (`LET`, `PRINT`, pass to function). Calling it as a bare statement is an error.
+- Errors halt the program with a line-numbered message: undefined variable, missing closing `-}}`, empty placeholder `{{--}}`, malformed array access, uninitialized array element.
 
-**Notes:** Whitespace inside placeholders is trimmed. Numbers auto-stringify. FSTRING returns a value and must be used — a bare `FSTRING(...)` statement is an error. Undefined names, missing `-}}`, empty `{{--}}`, malformed or uninitialized array access all halt with a line-numbered message.
+### Not supported (intentional)
 
-**Not supported:** arithmetic, function calls, nested lookups, or quoted literals inside placeholders. Pre-compute into a variable:
+No arithmetic, function calls, nested lookups, or quoted string literals inside placeholders. Pre-compute into a variable and reference that:
 
 ```basic
 ' ❌ WRONG
@@ -436,7 +542,19 @@ LET k$     = arr2$(0)
 PRINT FSTRING("Total: {{-total$-}}, Name: {{-upper$-}}, Item: {{-arr$(k$)-}}")
 ```
 
-**Full example:**
+### Common AI mistakes with FSTRING
+
+```basic
+' ❌ WRONG                                  ' ✓ CORRECT
+FSTRING("Hi {{name$}}")                     FSTRING("Hi {{-name$-}}")
+FSTRING("Hi {-name$-}")                     FSTRING("Hi {{-name$-}}")
+FSTRING("Hi {{-name-}}")    ' array key     FSTRING("Hi {{-name$-}}")
+FSTRING("Hi {{-name$-}}")   ' as stmt       LET s$ = FSTRING("Hi {{-name$-}}")
+```
+
+Inside a placeholder, `name` (no suffix) is treated as a literal string key for an array lookup, **not** as a reference to variable `name$`. Always include the suffix.
+
+### Full working example
 
 ```basic
 DIM player$
@@ -445,17 +563,25 @@ DIM player$
     player$("level") = 99
 
 DIM grid$
+    grid$(0, 0) = "X"
+    grid$(0, 1) = "O"
     grid$(1, 0) = "."
     grid$(1, 1) = "X"
 
 LET row$ = 1
+LET PI# = 3.14
 
 PRINT FSTRING("{{-player$(name)-}} the {{-player$(class)-}}, lvl {{-player$(level)-}}")
 PRINT FSTRING("Row {{-row$-}}: [{{-grid$(row$, 0)-}}{{-grid$(row$, 1)-}}]")
+PRINT FSTRING("Pi is roughly {{-PI#-}}")
 END
-' Output:
-' Krisu the Bass, lvl 99
-' Row 1: [.X]
+```
+
+Output:
+```
+Krisu the Bass, lvl 99
+Row 1: [.X]
+Pi is roughly 3.14
 ```
 
 ---
@@ -466,9 +592,9 @@ END
 |----------|-------------|
 | `ABS(n)` | Absolute value |
 | `ATAN(n)` | Arc tangent |
-| `ATAN2(y, x)` | Angle in radians from the positive x-axis to point (x, y) |
+| `ATAN2(n, n2)` | Returns the angle, in radians, between the positive x-axis and a vector to the point with the given (x, y) coordinates in the Cartesian plane |
 | `BETWEEN(n, min, max)` | TRUE if min ≤ n ≤ max |
-| `INBETWEEN(n, min, max)` | TRUE if min < n < max (strict) |
+| `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] |
@@ -481,39 +607,47 @@ END
 | `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)` / `a % b` | Remainder (function and operator forms are equivalent) |
+| `MOD(a, b)` | Remainder |
+| `a % b` | Same as `MOD(a, b)` — binary modulo operator form |
 | `POW(base, exp)` | Power |
-| `RND(n)` | Random integer 0 to n-1 (n > 0) |
-| `RND(0)` | Random float 0.0–1.0 |
-| `ROUND(n)` | Nearest integer, half away from zero (`0.5→1`, `-0.5→-1`) — NOT banker's rounding |
+| `RND(n)` | Random integer 0 to n-1 if n > 0 |
+| `RND(0)` | Float between 0.0 and 1.0 (IE: 0.5841907423666761) |
+| `ROUND(n)` | Rounds to nearest integer, half rounds away from zero (`0.5→1`, `-0.5→-1`) — NOT banker's rounding |
 | `SGN(n)` | Sign: -1, 0, or 1 |
 | `SQR(n)` | Square root |
 
-### Fast Trigonometry
-
-About 20× faster than `SIN(RAD(x))`, 1-degree precision, ~5.6 KB memory. Use for raycasting, sprite rotation, particle systems — anything calling trig hundreds of times per frame.
-
-```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
-```
+**Math constants:** `PI#`, `HPI#` (PI/2), `QPI#` (PI/4), `TAU#` (PI*2), `EULER#`
 
 ---
 
-## ISSET
-
-`ISSET(name)` returns `1` if the named variable (`$`) or constant (`#`) is declared, `0` otherwise. The argument is **not evaluated**, so `ISSET(undef$)` safely returns `0`.
+## Variable Functions
 
-- **Scalars only.** `ISSET(arr$)` and `ISSET(arr$(0))` always return `0`, never an error.
-- **Bare name only.** Expressions, string literals, numbers or an empty argument (`ISSET(a$ + b$)`, `ISSET("a$")`, `ISSET(42)`, `ISSET()`) error with "invalid parameter".
-- **Suffix is part of the name:** `a$` and `A#` are different names.
-- **`LET name$` without a value still counts as set.** ISSET reports declaration, not "has a meaningful value".
+| Function | Description |
+|----------|-------------|
+| `ISSET(name)` | `1` if the named variable (`$`) or constant (`#`) is declared, `0` otherwise. Argument is **not evaluated** — `ISSET(undef$)` safely returns `0`. |
+
+`ISSET` is the only language-introspection function and it has tight rules:
+
+- **Scalars only.** Variables (`$`) and constants (`#`). Arrays and array elements are stored separately — `ISSET(arr$)` and `ISSET(arr$(0))` always return `0`, never an error.
+- **Bare name only.** No expressions, no string literals, no numbers. These all error with "invalid parameter":
+  ```basic
+  ISSET(a$ + b$)   ' WRONG: expression
+  ISSET("a$")      ' WRONG: string literal
+  ISSET(42)        ' WRONG: number
+  ISSET()          ' WRONG: empty
+  ```
+- **Suffix is part of the name.** `a$` and `A#` are different names:
+  ```basic
+  LET a$ = "foo"
+  PRINT ISSET(a$)  ' 1
+  PRINT ISSET(A#)  ' 0
+  ```
+- **`LET name$` (no value) still counts as set.** `LET` always registers the variable; the value just defaults to empty string for `$` and zero for numeric. `ISSET` reports declaration, not "has a meaningful value".
+
+Typical use is guarding optional setup:
 
 ```basic
-IF ISSET(playerName$) = FALSE THEN
+IF NOT ISSET(playerName$) THEN
     LET playerName$ = "Anonymous"
 END IF
 ```
@@ -530,45 +664,65 @@ FULLSCREEN TRUE                     ' Borderless fullscreen (graphics only)
 FULLSCREEN FALSE                    ' Windowed
 ```
 
-Classic modes: 1, 7, 13 = 320×200 · 2, 9 = 640×350 · 12 = 640×480.
+| 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
-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)
+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 values:** All drawing primitives (`PSET`, `LINE`, `CIRCLE`, `PAINT`, `DRAWSTRING`, `LOADSHAPE`) accept a palette index 0–15 or an `RGB(r, g, b)` value. Never hand-construct packed integers (e.g. `16711680`) — `RGB()` tags its value internally, and a raw integer is misread as a palette index.
+**LINE corners:** `(x2, y2)` is inclusive in all forms (line, `B`, `BF`), and box corners may be in any order. `LINE (10,10)-(12,12), c, BF` fills 3×3 pixels; a box exactly `w` pixels wide ends at `x + w - 1`. (In v1.4c and older, `B`/`BF` excluded the second corner.)
+
+**Color values:** Every drawing primitive (`PSET`, `LINE`, `CIRCLE`, `PAINT`, `DRAWSTRING`, `LOADSHAPE`) accepts a `color` parameter that is either a palette index 0–15 or an `RGB(r, g, b)` value — mix freely. The `COLOR` text command is the exception: it accepts palette indices 0–15 only, so `COLOR RGB(...)` does **not** work.
 
 **Palette (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
 
+> Do **not** hand-construct packed RGB integers (e.g. `16711680`). `RGB()` tags its return value internally so it can be told apart from a palette index; a raw integer lacks that tag and will be misread as a palette index. Always use `RGB(r, g, b)`.
+
 ### Screen Control
 ```basic
-SCREENLOCK ON                       ' Start frame (buffer drawing)
-SCREENLOCK OFF                      ' Present buffer
-VSYNC(TRUE)                         ' Enable VSync (default) — loop runs at monitor refresh rate
+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
+' Use CLS only with console, in graphics screen its slow
+' With graphics screen, prefer LINE BF
 ```
 
 ### Shapes & Images
 ```basic
-LET RECT# = LOADSHAPE("RECTANGLE", w, h, color)   ' or "CIRCLE", "TRIANGLE"
+' 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
+LET IMG_REMOTE# = LOADIMAGE("https://example.com/a.png") ' Download + load
 
 ' Sprite sheet — sprites indexed 0-based
 DIM sprites$
-LOADSHEET sprites$, 128, 128, "sheet.png"         ' tileW, tileH, file
-MOVESHAPE sprites$(0), x, y
+LOADSHEET sprites$, 128, 128, "sheet.png"        ' tileW, tileH, file
+MOVESHAPE sprites$(0), x, y                      ' sprites$(0) = first sprite
 
-MOVESHAPE RECT#, x, y               ' Position
+' Transform
+' NOTE: anchor point differs by type — LOADSHAPE primitives (RECTANGLE/CIRCLE/TRIANGLE)
+' are center-anchored; LOADIMAGE images are top-left-anchored.
+MOVESHAPE RECT#, x, y               ' Position by center point (LOADSHAPE shape)
 ROTATESHAPE RECT#, angle            ' Degrees (absolute)
 SCALESHAPE RECT#, scale             ' 1.0 = original size
 DRAWSHAPE RECT#                     ' Render to buffer
@@ -576,28 +730,39 @@ SHOWSHAPE RECT# / HIDESHAPE RECT#   ' Toggle visibility
 REMOVESHAPE RECT#                   ' Free memory (always clean up)
 ```
 
-**Anchor point:** `LOADSHAPE` primitives are center-anchored; `LOADIMAGE` images are top-left-anchored.
 
-### Text Rendering (requires SDL2_ttf.dll next to the interpreter)
+---
+
+### Text Rendering (SDL2_ttf.dll required)
+#### DRAWSTRING & LOADFONT
+
 
 ```basic
-DRAWSTRING "Hello!", 100, 200, WHITE#   ' Default font: Arial, 16px
-LOADFONT "comic.ttf", 24                ' Becomes the new default
-LOADFONT                                ' Reset to Arial 16px
+' Default font: Arial, 16px
+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, 16px
+LOADFONT
 ```
 
-`DRAWSTRING text, x, y, color` positions the top-left of the text.
+`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. Default font size is **16px** — not 20px.
 
 ---
 
 ## 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
+SOUNDONCEWAIT(SND_JUMP#)               ' Play once, wait for finish
+SOUNDREPEAT(SND_JUMP#)                 ' Loop continuously
+SOUNDSTOP(SND_JUMP#)                   ' Stop specific sound
 SOUNDSTOPALL                            ' Stop all sounds
 ```
 
@@ -608,27 +773,32 @@ 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 (array → key=value format)
-FILEAPPEND "log.txt", entry$             ' Append
-LET ok$ = FILEEXISTS("file.txt")         ' 1=exists, 0=not
-FILEDELETE "temp.dat"                    ' Delete file
+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
 DIM files$
-LET n$ = FILELIST(files$, "levels", "*.txt")  ' Names into files$(0..n-1), returns n
+LET n$ = FILELIST(files$, "levels", "*.txt")  ' File names into files$(0..n-1), returns n
 ```
 
-**key=value parsing:** When `FILEREAD` assigns to a `DIM`'d array, lines `key=value` become `arr$("key")`; lines starting with `#` are comments. Round-trips with `FILEWRITE`. Good for `.env` files:
+**FILELIST:** `FILELIST(arr$, folder$ [, pattern$])` lists files only (no folders, not recursive), names only (no paths), sorted alphabetically ignoring case. The array is cleared first. `pattern$` supports `*` and `?`, default all files. Hidden/system files are skipped. Missing folder → returns `0`. To open a listed file, prepend the folder: `FILEREAD("levels/" + files$(i$))`. Added in v1.5.
+
+**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 env$ = FileRead(".env")
 LET API_KEY# = env$("OPENAI_API_KEY")
 ```
 
-**FILELIST:** files only (no folders, not recursive), names only (no paths), sorted alphabetically ignoring case, hidden/system files skipped. The array is cleared first. Pattern supports `*` and `?`, default all files. Missing folder → returns `0`. To open a listed file, prepend the folder: `FILEREAD("levels/" + files$(i$))`.
-
-**Paths:** Use `/` or `\\` — never a single `\` (escape char). Relative paths are from `PRG_ROOT#`, which already ends with a separator: `PRG_ROOT# + "data.txt"`.
+**Paths:** Use `/` or `\\` — never single `\` (it's an escape char). Relative paths are from `PRG_ROOT#`.
+`PRG_ROOT#` already ends with a directory separator — concatenate directly, don't add your own `/`:
+```basic
+LET path$ = PRG_ROOT# + "data.txt"
+```
+**FileWrite with array** saves in key=value format (round-trips with FileRead).
 
 ---
 
@@ -638,35 +808,41 @@ LET API_KEY# = env$("OPENAI_API_KEY")
 LET res$ = HTTPGET("https://api.example.com/data")
 LET res$ = HTTPPOST("https://api.example.com/submit", "{""key"":""val""}")
 
-' Optional headers
+' With headers (optional)
 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$)
 
-' Optional timeout in seconds, AFTER headers (default 30, 0 = no limit)
+' With timeout in seconds (optional, comes AFTER headers; default 30, 0 = no limit)
+LET res$ = HTTPGET("https://api.example.com/data", headers$, 60)
 LET res$ = HTTPPOST("http://localhost:11434/v1/chat/completions", body$, headers$, 120)
 ```
 
 ### Local HTTP server (LISTEN)
 
-Local-only server, typically glue between a static HTML page and a BazzBasic script on the same machine.
+BazzBasic can also receive requests as a local-only HTTP server, typically used as glue between a static HTML page and a BazzBasic script on the same machine.
 
 ```basic
-STARTLISTEN 8080                       ' Bind 127.0.0.1:8080, no admin needed
-STARTLISTEN 8080, 5000                 ' Optional timeout in ms
-LET body$ = GETREQUEST()               ' POST/PUT/PATCH body or GET query string ("" on timeout)
-SENDRESPONSE "{""status"":""ok""}"     ' Must be called or the browser hangs
+STARTLISTEN 8080                       ' bind 127.0.0.1:8080, no admin needed
+STARTLISTEN 8080, 5000                 ' optional timeout in ms
+LET body$ = GETREQUEST()               ' POST/PUT/PATCH body, or GET query string ("" on timeout)
+SENDRESPONSE "{""status"":""ok""}"     ' must be called or browser hangs
 STOPLISTEN
 ```
 
-- **Always pair `GETREQUEST()` with `SENDRESPONSE`.**
-- **Bound to `127.0.0.1` only.** Do not generate code that tries to expose it on a LAN or the internet.
-- **Body or query string only** (no `?`). Headers, method and URL path are not exposed. Parse JSON bodies with `ASARRAY`.
-- **OPTIONS preflight and CORS are automatic.** Don't handle `OPTIONS`; every response carries `Access-Control-Allow-Origin: *`.
-- **One listener at a time.** Call `STOPLISTEN` before another `STARTLISTEN`.
-- **Always 200 OK, always `text/plain`.** To return JSON, put JSON text in the body — browser-side `response.json()` still works.
+Important rules:
+
+- **Always pair `GETREQUEST()` with `SENDRESPONSE`.** The browser is waiting on the response. Forgetting `SENDRESPONSE` makes the page hang.
+- **Bound to `127.0.0.1` only.** This is local glue, not a real web server. Do not generate code that tries to expose this on the LAN or internet.
+- **Body or query string, not full request.** `GETREQUEST()` returns just the POST body (or the GET query string without `?`). Headers, method, and URL path are NOT exposed in this version. If you need structured data, parse the body with `ASARRAY(body$)`.
+- **OPTIONS preflight is automatic.** Do NOT write code that handles `OPTIONS` — it is consumed silently and never reaches user code.
+- **CORS is automatic.** Every response carries `Access-Control-Allow-Origin: *`. No need to set it manually.
+- **One listener at a time.** Calling `STARTLISTEN` while one is already active is an error. Call `STOPLISTEN` first.
+- **Always 200 OK, always `text/plain`.** Custom status codes and content types are not supported in this version. To return JSON, just put JSON text in the body — browser-side `response.json()` still works.
+
+Typical receive-and-process pattern:
 
 ```basic
 STARTLISTEN 8080
@@ -674,7 +850,8 @@ PRINT "Waiting for browser..."
 
 LET json$ = GETREQUEST()
 DIM data$
-LET count$ = ASARRAY(data$, json$)
+LET data$ = ASARRAY(json$)
+
 PRINT "Got name: " + data$("name")
 
 SENDRESPONSE "{""status"":""ok""}"
@@ -686,70 +863,66 @@ END
 
 ## Arrays & JSON
 
-Nested JSON maps to comma-separated keys: `data$("player,name")`, `data$("skills,0")`.
+Nested JSON maps to comma-separated keys: `data$("player,name")`, `data$("skills,0")`
 
 ```basic
-LET json$ = ASJSON(arr$)                 ' Array → JSON string
+' Array → JSON string (an empty array gives "{}")
+LET json$ = ASJSON(arr$)
+
+' JSON string → array (returns element count)
 DIM data$
-LET count$ = ASARRAY(data$, json$)       ' JSON string → array, returns element count
-LOADJSON arr$, "file.json"               ' Load JSON file
-SAVEJSON arr$, "file.json"               ' Save JSON file
-```
+LET count$ = ASARRAY(data$, json$)
 
-### Passing Arrays to Functions
+' Load/save JSON files
+LOADJSON arr$, "file.json"
+SAVEJSON arr$, "file.json"
+```
 
-Serialize with `ASJSON`, pass the string, rebuild inside with `ASARRAY`. The function gets an independent copy — changes inside do not affect the original. Nested keys work normally.
+---
 
-```basic
-DEF FN ProcessPlayer$(data$)
-    DIM arr$
-    LET count$ = ASARRAY(arr$, data$)
-    RETURN arr$("name") + " score:" + arr$("score")
-END DEF
+## Fast Trigonometry
 
-[inits]
-    DIM player$
-    player$("name") = "Alice"
-    player$("score") = 9999
-    player$("address,city") = "New York"
+~20× faster than `SIN(RAD(x))`, 1-degree precision. Uses ~5.6 KB memory.
 
-[main]
-    LET json$ = ASJSON(player$)
-    PRINT FN ProcessPlayer$(json$)
-END
+```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.
+
 ---
 
 ## Date & Time
 
 ```basic
-LET t$  = TIME()                   ' Default "HH:mm:ss" -> "15:21:22"
-LET t2$ = TIME("dd.MM.yyyy")       ' .NET DateTime format -> "04.09.2026"
+LET t$ = TIME()                    ' Current time, default format "HH:mm:ss" -> "15:21:22"
+LET t2$ = TIME("dd.MM.yyyy")       ' .NET DateTime format string -> "04.09.2026"
 LET t3$ = TIME("dddd")             ' -> "Friday"
+
 LET start$ = TICKS                 ' Milliseconds since program start
+' ... later in a loop ...
+LET elapsed$ = TICKS - start$      ' Delta time — use for frame-independent movement
 ```
 
-**Timing — SLEEP and TICKS do different jobs:**
-- **Frame pacing:** in graphics mode, VSync (on by default) waits at `SCREENLOCK OFF`, limiting the loop to the monitor's refresh rate — usually 60 FPS, but 144 FPS on a 144 Hz monitor. Do NOT add `SLEEP 16` to a graphics loop — together they halve the frame rate.
-- **SLEEP ms:** use for deliberate pauses (title screens, "Game Over" delays) and to keep console loops from using 100% CPU (`SLEEP 10` in an `INKEY` polling loop).
-- **TICKS:** use for measuring time — timers, cooldowns, animation speed, and movement that should stay the same speed on every monitor.
+`TICKS` is the standard way to do frame-independent (delta-time) movement in a game loop — prefer it over counting fixed `SLEEP` increments.
 
 ```basic
-[inits]
-    LET running$ = TRUE
-    LET lastTick$ = TICKS
-    LET delta$
-    LET x$ = 0, speed$ = 2          ' several variables in one LET
+' ✅ Preferred: frame-independent movement
+LET lastTick$ = TICKS
+WHILE running$
+    LET delta$ = TICKS - lastTick$
+    lastTick$ = TICKS
+    x$ = x$ + speed$ * delta$ / 16   ' normalize to ~60 FPS baseline
+    GOSUB [sub:draw]
+WEND
 
-[main]
-    WHILE running$
-        delta$ = TICKS - lastTick$
-        lastTick$ = TICKS
-        x$ = x$ + speed$ * delta$ / 16   ' same speed regardless of frame rate
-        GOSUB [sub:draw]
-    WEND
-END
+' ❌ Avoid: fixed SLEEP without delta — speed varies with actual frame rate
+SLEEP 16
+x$ = x$ + speed$
 ```
 
 ---
@@ -758,12 +931,12 @@ END
 
 ```basic
 ' bazzbasic.exe myprog.bas arg1 arg2
-PRINT ARGCOUNT         ' 2
-PRINT ARGS(0)          ' "arg1"
-PRINT ARGS(1)          ' "arg2"
+PRINT ARGCOUNT         ' number of args (2 in this example)
+PRINT ARGS(0)          ' first arg  → "arg1"
+PRINT ARGS(1)          ' second arg → "arg2"
 ```
 
-0-based; does not include the interpreter or script name.
+`ARGCOUNT` and `ARGS(n)` are 0-based; ARGS does not include the interpreter or script name.
 
 ---
 
@@ -779,30 +952,60 @@ INCLUDE "MathLib.bb"                ' Load compiled library
 PRINT FN MATHLIB_add$(5, 3)
 ```
 
-- Library functions can read main-program constants (`#`).
-- `.bb` files are **version-locked** to the build that produced them — recompile after upgrading.
-- **No extension fallback:** `INCLUDE "helpers"` does NOT try `helpers.bas`.
-- **Path resolution:** relative to the including file's directory first, then the program's base path.
-- **Circular includes** halt with `Circular INCLUDE detected: <file>`.
+Library functions can read main-program constants (`#`). `.bb` files are version-locked.
+
+- **No extension fallback.** `INCLUDE "helpers"` does NOT try `helpers.bas` automatically — give the exact filename, extension included.
+- **Path resolution order:** relative to the *including file's own directory* first, then relative to the program's base path.
+- **Circular includes are detected** and halt with `Circular INCLUDE detected: <file>`.
+
+---
+
+## 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) ----
+' ---- 1. FUNCTIONS (or INCLUDE "functions.bas/bb") ----
 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 ----
+' ---- 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
-    LET PLAYER_COLOR# = RGB(0, 255, 0)
+	LET SCREEN_W# = 640
+	LET SCREEN_H# = 480
+	LET MAX_SPEED# = 5
 
     SCREEN 0, SCREEN_W#, SCREEN_H#, "My Game"
 
@@ -815,12 +1018,13 @@ END DEF
     WHILE running$
         IF INKEY = KEY_ESC# THEN running$ = FALSE
         GOSUB [sub:update]
-        GOSUB [sub:draw]            ' SCREENLOCK OFF + VSync paces the loop to the monitor refresh rate
+        GOSUB [sub:draw]
+        SLEEP 16
     WEND
     SOUNDSTOPALL
-END
+END ' place at the end of main program so BazzBasic wont fall to subs in runtime
 
-' ---- 4. SUBROUTINES (or INCLUDE) ----
+' ---- 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#
@@ -829,37 +1033,139 @@ RETURN
 [sub:draw]
     SCREENLOCK ON
     LINE (0,0)-(SCREEN_W#, SCREEN_H#), 0, BF
-    CIRCLE (x$, y$), 10, PLAYER_COLOR#, 1
+    CIRCLE (x$, y$), 10, RGB(0, 255, 0), 1
     SCREENLOCK OFF
 RETURN
 ```
 
-**Naming conventions:** variables `camelCase$`, constants `UPPER_SNAKE_CASE#`, functions `PascalCase$`, labels `[gameLoop]` for jump targets and `[sub:name]` for subroutines.
+**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
+## Known Limitations
+
+Things to be aware of — most are deliberate design decisions, a few are practical constraints.
+
+- **No line numbers.** Never supported, never will be.
+- **Platform: Windows x64 only.** Linux and macOS are not supported. Browser/Android are not feasible — the runtime depends on SDL2 via P/Invoke.
+- **Arrays cannot be passed to functions.** Use the `ASJSON` / `ASARRAY` round-trip pattern. The function receives an independent copy.
+- **`DEF FN` scope is fully isolated.** Functions can read global `#` constants but cannot see any `$` variables or arrays from the outer scope. Pass values as parameters, arrays as `ASJSON()` strings.
+- **No block scope.** `IF`, `FOR`, and `WHILE` do not create new variable scopes — all main-code variables share one namespace.
+- **No exception handling.** There is no `TRY`/`CATCH` and no `ON ERROR`. Runtime errors halt the program with a line-numbered message printed to the console, and the process exits with code 1.
+- **Division by zero returns `0` silently.** No exception, no warning. Guard with `IF b$ = 0 THEN ...` when correctness matters.
+- **No integer-division operator.** Use `INT(a / b)`, `FLOOR(a / b)`, or `CINT(a / b)` depending on the rounding behavior you need.
+- **Compiled `.bb` libraries are version-locked** to the BazzBasic build that produced them. Recompile after upgrading the interpreter.
+- **`DEF FN` definitions must precede their first call** in source order. Forward references don't resolve.
+
+---
+
+## Interpreter, IDE and Command Line
+
+### Two programs: BazzBasic.exe and BazzBasic-IDE.exe
+
+BazzBasic ships as two programs in the same folder:
+
+| File | What it is |
+|------|------------|
+| `BazzBasic.exe` | The interpreter — a console program that runs and compiles `.bas` files (~15 MB) |
+| `BazzBasic-IDE.exe` | The code editor — a Windows program (~111 MB, WinForms + Scintilla) |
+
+- Command line, `.bat` files, other editors (Notepad++, Geany, VS Code), PATH and `.bas` file associations all keep using `BazzBasic.exe` as before.
+- Running `BazzBasic.exe` with no arguments (or double-clicking it) starts `BazzBasic-IDE.exe` from the same folder. If the IDE isn't there, it prints the command-line usage instead.
+- To use only the interpreter with another editor, `BazzBasic-IDE.exe` and the `runtimes` folder can be left out; the interpreter only needs the SDL2 DLLs next to it.
+- **Compiled programs** (`-exe` / Compile as Exe) are a copy of the interpreter with the code inside, so they are about 15 MB.
+- **Before v1.6 this was completely different:** `BazzBasic.exe` was the IDE and the interpreter in one ~111 MB file, and every compiled program was that size too. There was no `BazzBasic-IDE.exe`. If a user describes a single exe, they are on an older version.
 
-From version 1.6, the IDE (`BazzBasic-IDE.exe`) and interpreter (`BazzBasic.exe`) are separate programs in the same release .zip. Launching the interpreter without arguments tries to open the IDE; if that fails, it prints a message to the console.
+### Command-line options
 
+| Command | Action |
+|---------|--------|
+| `bazzbasic.exe file.bas [args...]` | Run a program (`ARGS`/`ARGCOUNT` see the extra arguments) |
+| `bazzbasic.exe -exe file.bas` | Compile to a standalone `.exe` |
+| `bazzbasic.exe -lib file.bas` | Compile to a `.bb` library |
+| `bazzbasic.exe -v` / `-version` | Print version |
+| `bazzbasic.exe -guide` / `-help` | Print the Beginner's Guide URL |
+| `bazzbasic.exe -checkupdate` / `-checkupdates` | Check for a newer release |
+| `bazzbasic.exe` (no arguments) | Start the IDE |
+
+**Exit code:** a program that stops on a runtime error exits with code **1**, a normal end with **0**. This also applies to compiled executables, so `.bat` files and scripts can test `ERRORLEVEL`. (Before v1.6, errors also exited with 0.)
+
+---
+
+## IDE Features
+
+### Menus
 | Menu | Items |
 |------|-------|
-| **File** | New, Open, Save, Save As, Save All, Close Tab, Close All, Restore Session on Startup¹, Print, Exit |
-| **Edit** | Undo, Redo, Cut, Copy, Paste, Select All, Comment Selection, Uncomment Selection |
-| **Search** | Find, Replace |
-| **View** | Tree View¹ (DEF FN functions and labels on the left), Open Console², Open File Browser², Light Mode¹, Dark Mode (experimental)¹, Syntax Coloring¹ (off = monochrome), Take a Screenshot to Clipboard (IDE window only), Zoom In, Zoom Out |
-| **Run** | Run Program (F5), Compile as Exe, Compile as Library (.bb), Path to BazzBasic.exe³ |
-| **Help** | About, Homepage, Online Manual, Beginner's Guide, Rosetta Code, Check for Updates |
-
-¹ Saved to `%AppData%\BazzBasic\ide.json`  
-² Opens in the current file's folder  
-³ Used if set; otherwise the IDE's own folder, then `PATH`
-
-- Compile commands auto-save the file first.
-- Help-menu links open the URLs listed at the top of this guide.
-- CLI equivalents: `bazzbasic.exe -guide` / `-help` prints the Beginner's Guide URL, `bazzbasic.exe -checkupdates` checks for a newer version.
-- New files get this template:
-```basic
-  ' BazzBasic version {ver_num}
-  ' https://ekbass.github.io/BazzBasic/
-```
+| **File** | New (Ctrl+N), Open (Ctrl+O), Save (Ctrl+S), Save As (Ctrl+Shift+S), Save All, Close Tab (Ctrl+W), Close All, Restore Session on Startup (check mark), Print (Ctrl+P), Exit (Alt+F4) |
+| **Edit** | Undo (Ctrl+Z), Redo (Ctrl+Y), Cut (Ctrl+X), Copy (Ctrl+C), Paste (Ctrl+V), Select All (Ctrl+A), Comment Selection (Ctrl+Q), Uncomment Selection (Ctrl+Shift+Q) |
+| **Search** | Find (Ctrl+F), Replace (Ctrl+H) |
+| **View** | Tree View (check mark), Open Console, Open File Browser, Light Mode, Dark Mode (experimental), Take Screenshot to Clipboard, Zoom In (Ctrl++), Zoom Out (Ctrl+-) |
+| **Run** | Run Program (F5), Compile as Exe, Compile as Library (.bb), Path to BazzBasic.exe... |
+| **Help** | About, Homepage, Online Manual, Beginner's Guide, Rosetta Code, Check for Updates... |
+
+All IDE settings (theme, session, Tree View, window placement, interpreter path) are saved to `%AppData%\BazzBasic\ide.json`.
+
+**Version note:** the IDE before v1.6 was much more limited. It had no Save All, Close All, session restore, Print, Comment/Uncomment Selection, Tree View, Zoom, screenshot, Open Console/File Browser, Path to BazzBasic.exe or Help → Homepage, and it did not remember its window size. In v1.4c and older, Find and Replace were under **Edit** and there was no View menu. If a user can't find a menu item, ask which version they run.
+
+### Editing
+- **Comment Selection (Ctrl+Q)** adds `' ` to the start of every selected line (or the cursor line). BazzBasic has no block comments, so this is the way to disable a block of code. **Uncomment Selection (Ctrl+Shift+Q)** removes a leading `'` (and one following space), also after indentation; `REM` lines are not touched. Each is one Undo step.
+- **Zoom In / Zoom Out** changes the editor text size of the active tab. Both numpad and main-keyboard `+`/`-` work.
+
+### Tree View
+**View → Tree View** shows a panel left of the editor listing the active file's **Functions** (every `DEF FN` line, with parameters) and **Labels** (every `[label]` alone on its line, e.g. `[sub:draw]`). Clicking an item jumps to that line. Updates half a second after typing stops. Code from `INCLUDE` files is not listed. Width is adjustable by dragging.
+
+### Files, tabs and sessions
+- **Save All** saves every modified tab (Untitled tabs open Save As). **Close All** closes all tabs, asking Yes/No/Cancel for each modified one.
+- Closing the IDE (X, Alt+F4, File → Exit) asks to save each modified tab; Cancel keeps it open.
+- **Restore Session on Startup** (off by default): reopens the files that were open last time and selects the active tab. Untitled tabs aren't restored; missing files are skipped and listed once.
+- The IDE remembers its window size, position and maximized state between sessions.
+- **Print (Ctrl+P)** prints the active file with syntax highlighting on white paper. Choose *Microsoft Print to PDF* to make a PDF.
+
+### Running programs
+- **Run Program (F5)** saves the file and runs it in a console window. A file that already has a name is saved over; an Untitled file opens the Save As dialog first. If the program stops on an error, the console stays open showing the error until a key is pressed; a normal end closes it.
+- **Run → Path to BazzBasic.exe...** sets which interpreter Run and Compile use. Lookup order: the path set here → the IDE's own folder → `PATH`. If a set path no longer exists, the IDE says so instead of silently using another one.
+
+### Other tools
+- **View → Open Console** / **Open File Browser** open `cmd.exe` / File Explorer in the active file's folder (Untitled tab → the IDE's folder).
+- **View → Take Screenshot to Clipboard** copies an image of the IDE window only. When asking for help, prefer sharing the code as text; use the screenshot when the layout or an error dialog matters.
+- **Help → Homepage** opens https://ekbass.github.io/BazzBasic/.
+
+### New File Template
+When the IDE opens with no file (or a new file), this template is auto-inserted:
+```basic
+' BazzBasic version {ver_num}
+' 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
+
+### Online Manual and Rosetta Code
+- **IDE:** Menu → **Help** → **Online Manual** — opens `https://ekbass.github.io/BazzBasic/manual/#/` in default browser
+- **IDE:** Menu → **Help** → **Rosetta Code** — opens `https://rosettacode.org/wiki/Category:BazzBasic` in default browser
+- No CLI equivalents
+
+### Check for Updates
+- **IDE:** Menu → **Help** → **Check for Updates...** — IDE reports if a newer version is available
+- **CLI:** `bazzbasic.exe -checkupdates`
+
+### 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)